几种常用的设计模式浅析

一，创建型模式（主要用于创建对象）

1.工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪个。

例如：FactoryMethodModel

Factory.java

package FactoryMethodModel;
public abstract class Factory {
public abstract Phone createPhone();
}

HuaWeiFactory.java

package FactoryMethodModel;
public class HuaweiFactory extends Factory{
public Phone createPhone() {
return new HuaweiPhone(256);
}
}

HuaWeiPhone.java

package FactoryMethodModel;
/**
 * 产品的具体类
 * @author minGe_000
 *
 */
public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个华为手机");
}
}

Iphone.java

package FactoryMethodModel;
/**
 * 苹果手机类具体类
 * @author minGe_000
 *
 */
public class IPhone extends Phone{
public IPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个苹果手机");
}
}

IphoneFactory.java

package FactoryMethodModel;
public class IPhoneFactory extends Factory{
public Phone createPhone() {
return new IPhone(246);
}
}

Phone.java

package FactoryMethodModel;
/**
 * 产品的抽象父类
 * @author minGe_000
 *
 */
public abstract class Phone {
public int size;
public Phone(int size) {
super();
this.size = size;
}
public abstract void descript();
}

Test.java

package FactoryMethodModel;


public class Test {
public static void main(String[] args) {
// //需要苹果手机对象,高耦合性
// Phone phone1 = PhoneFactory.createPhone("huawei");
// Phone phone2 = PhoneFactory.createPhone("iphone");
//
// phone1.descript();
// phone2.descript();
//构造一个华为工厂对象
Factory factory = new HuaweiFactory();
Phone phone1 = factory.createPhone();
}
}

2.简单工厂方法模式

例如：SimpleFactoryModel

HuaweiPhone.java

package SimpleFactoryModel;
/**
 * 产品的具体类
 * @author minGe_000
 *
 */
public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个华为手机");
}
}

Iphone.java

package SimpleFactoryModel;
/**
 * 苹果手机类具体类
 * @author minGe_000
 *
 */
public class IPhone extends Phone{
public IPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个苹果手机");
}
}

Phone.java

package SimpleFactoryModel;
/**
 * 产品的抽象父类
 * @author minGe_000
 *
 */
public abstract class Phone {
public int size;
public Phone(int size) {
super();
this.size = size;
}
public abstract void descript();
}

PhoneFactory.java

package SimpleFactoryModel;
public class PhoneFactory {
/**
* 工厂函数
* @return
*/
public static Phone createPhone(String type){
Phone  phone = null;
if("iphone".equals(type)){
phone = new IPhone(256);
}else if("huawei".equals(type)){
phone = new HuaweiPhone(256);
}
return phone;
}
}

Test.java

package SimpleFactoryModel;
public class Test {
public static void main(String[] args) {
//需要苹果手机对象,高耦合性
Phone phone1 = PhoneFactory.createPhone("huawei");
Phone phone2 = PhoneFactory.createPhone("iphone");
phone1.descript();
phone2.descript();
}
}

3.单例模式

SingleObjectModel

例如：

Student.java

package SingleObjectModel;
/**
 * 单利模式
 * @author minGe_000
 *
 */
public class Student {
public String name;
//1.构造方法私有化
private Student(){}
private Student(String name){
this.name = name;
}
//2.提供唯一的对象
private static Student stu;
//3.提供一个get实例的函数
public static synchronized Student getInstance(String n){
if(stu==null){
stu = new Student(n);
}
return stu;
}
}

Test.java

package SingleObjectModel;
public class Test {
        /**
* @param args
*/
public static void main(String[] args) {
new Thread(){
public void run() {
Student stu = Student.getInstance("abc");
};
}.start();
new Thread(){
public void run() {
Student stu1 = Student.getInstance("abc");
};
}.start();
new Thread(){
public void run() {
Student stu2 = Student.getInstance("abc");
};
}.start();
}
二，结构型模式（用于处理类或对象的组合）

装饰模式（DecoratorModel)

例如：

BeefDecorator.java

package DecoratorModel;
public class BeefDecorator extends Decorator{
public BeefDecorator(Cake cake) {
super(cake);
}
@Override
public float price() {
return super.price()+2.0f;
}
@Override
public String description() {
return super.description()+"+牛排";
}

public void test2(){
System.out.println("测试2");
}
}

Cake.java

package DecoratorModel;
/**
 * 被装饰者的抽象父类
 * @author minGe_000
 *
 */
public interface Cake {
public float price();
public String description();
}

Decorator.java

package DecoratorModel;
/**
 * 装饰着的父类
 * @author minGe_000
 *
 */
public abstract class Decorator implements Cake{
//体现和被装饰者的关联关系
private Cake cake;
public Decorator(Cake cake){
this.cake = cake;
}
public float price() {
return cake.price();
}
public String description() {
return cake.description();
}
}

EggDecorator.java

package DecoratorModel;
/**
 * 装饰着的具体实体类
 * @author minGe_000
 *
 */
public class EggDecorator extends Decorator{
public EggDecorator(Cake cake) {
super(cake);
}
@Override
public float price() {
return super.price()+1.5f;
}
@Override
public String description() {
return super.description()+"+鸡蛋";
}

public void test(){
System.out.println("鸡蛋装饰测试函数");
}
}

GraspCake.java

package DecoratorModel;
/**
 * 被装饰者的实体类（手抓饼）
 * @author minGe_000
 *
 */
public class GraspCake implements Cake{
public float price() {
return 3.0f;
}
public String description() {
return "您点了一个原味手抓饼";
}
}

Test.java

package DecoratorModel;


import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;


public class Test {
public static void main(String[] args) {
InputStream ins;
InputStream fis = new FileInputStream();
InputStream ois = new ObjectInputStream(fis);
InputStream dis = new DataInputStream(ois);

Cake gc = new GraspCake();
Cake ed = new EggDecorator(gc);
Cake bf = new BeefDecorator(gc);
System.out.println(bf.price());
System.out.println(bf.description());
}
}

三，行为型模式（用于描述对类或对象怎样交互和怎样分配职责）

观察者模式

例如：

Observer.java

package ObserverModel;
/**
 * 被观察者抽象父类
 * @author minGe_000
 *
 */
public interface Observer {
public void reciveMsg(String msg);
}

Student.java

package ObserverModel;
/**
 * 被观察者的实体类
 * @author minGe_000
 *
 */
public class Student implements Observer{
private String name;

public Student(String name) {
this.name = name;
}
       public void reciveMsg(String msg) {
System.out.println(name+"收到一条消息:"+msg);

}
}

Teacher.java

package ObserverModel;
import java.util.ArrayList;
/**
 * 观察者的实体类
 * @author minGe_000
 *
 */
public class Teacher implements Watcher{
private ArrayList<Observer> list = new ArrayList<Observer>();
public void addObserver(Observer obs) {
list.add(obs);
}
public void removeObserver(Observer obs) {
list.remove(obs);
}
public void notifys(String msg) {
//遍历队列，并通知到位每一个被观察对象
for (Observer obs : list) {
obs.reciveMsg(msg);
}
}
}

Test.java

package ObserverModel;


import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;


import javax.swing.JFrame;


public class Test {
public static void main(String[] args) {
Student stu1 = new Student("漳卅");
Student stu2 = new Student("李四");
Student stu3 = new Student("王五");
Student stu4 = new Student("赵六");

Teacher tea = new Teacher();
tea.addObserver(stu1);
tea.addObserver(stu2);
tea.addObserver(stu3);
tea.addObserver(stu4);

tea.notifys("成绩还没出来了，请不要查成绩");


JFrame jf = new JFrame();
MouseListener ml = new MouseListener() {

@Override
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub

}
};
jf.addMouseListener(ml);
}
}

Watcher.java

package ObserverModel;
/**
 * 观察者抽象父类
 * @author minGe_000
 *
 */
public interface Watcher {
public void addObserver(Observer obs);
public void removeObserver(Observer obs);
public void notifys(String msg);
}