设计模式

设计模式类型

• 创建型： 对象创建的抽像，管理对象的创建
• 结构型： 组合封装类或对象得到更的大结构
• 行为型：类或对象的协作

创建型

abstract factory抽像工厂。

抽像工厂：实现对象的可配置的、动态的创建，面向接口的,把所有的工厂类抽像出来一个公共的抽像类，注意抽的是工厂

builber

factory method

在Factory Method模式中，父类决定实例的生成方式，但并不决定所要生成的具体的类，具体的处理全部交给子类负责，这样就可以将生成实例的框架和实际负责生成实例的类解耦

public abstract class Factory {
    public final Product create(String owner) {
        Product p = createProduct(owner);
        registerProduct(p);
        return p;
    }

    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}
public class IDCardFactory extends Factory {
    private List owners = new ArrayList();
    @Override
    protected Product createProduct(String owner) {
        return new IDCard(owner);
    }

    @Override
    protected void registerProduct(Product product) {
        owners.add(((IDCard)product).getOwner());
    }
}

prototype

原型 clone对象

singleton

单利 应用中只出现一个对象

结构型

adapter

Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

bridge桥梁

本质上聚合抽像与实现

继承关系是强关联，而聚合关系是弱关联。将两个角色之间的继承关系改为聚合关系，就是将它们之间的强关联改换成为弱关联，因此，桥梁模式中的所谓脱耦，就是指在一个软件系统中的抽象化和实现化之间使用聚合关系，而不是继承关系，从而使两者可以相对对立的变化。

compostie合成模式

合成模式，合成模式把部分和整体的关系用树结构表示出来。合成模式使得客户端
把一个个单独的成分对象和由它们复合而成的合成对象同等看待

decorator装饰者

本质上将实现或继承目标后再通过聚合方式达到装饰

装饰模式是用来替代继承的一种设计模式。它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联（聚合）关系取代类之间的继承关系。降低了系统的耦合，可以动态的增加或者删除对象的职责

facade

一组接口统一成一个接口

flyweight共享

主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类

proxy

所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。代理可以对对象的拦截操作，像拦截器啊AOP啊，JAVA有两种方式，静态与动态

行为型

chain

 使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条线，并沿着这条链传递该请求，直至有对象处理它为止。

command

命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。
命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。

interpreter

Iterator模式可以顺序的访问一个聚集中的元素而不必暴露聚集的内部情况。
public interface Teacher {
    public Iterator createIterator(); //点名
}
public class ConcreteTeacher implements Teacher{
    private Object[] present = {"张三来了","李四来了","王五没来"}; //同学出勤集合
    public Iterator createIterator(){
        return new ConcreteIterator(this); //新的点名    }
    public Object getElement(int index){ //得到当前同学的出勤情况
        if(index<present.length){
            return present[index];
        }
        else{
            return null;
        }
    }
    public int getSize(){
        return present.length; //得到同学出勤集合的大小,也就是说要知道班上有多少人    }
}


public interface Iterator {
    void first(); //第一个
    void next(); //下一个
    boolean isDone(); //是否点名完毕
    Object currentItem(); //当前同学的出勤情况
}


public class ConcreteIterator implements Iterator{
    private ConcreteTeacher teacher;
    private int index = 0;
    private int size = 0;
    public ConcreteIterator(ConcreteTeacher teacher){
        this.teacher = teacher;
        size = teacher.getSize(); //得到同学的数目
        index = 0;
    }
    public void first(){ //第一个
        index = 0;
    }
    public void next(){ //下一个
        if(index<size){
            index++;
        }
    }
    public boolean isDone(){ //是否点名完毕
        return (index>=size);
    }
    public Object currentItem(){ //当前同学的出勤情况
        return teacher.getElement(index);
    }
}


public class Test {
    private Iterator it;
    private Teacher teacher = new ConcreteTeacher();
    public void operation(){
        it = teacher.createIterator(); //老师开始点名
        while(!it.isDone()){ //如果没点完
            System.out.println(it.currentItem().toString()); //获得被点到同学的情况
            it.next(); //点下一个        }
    }
    public static void main(String agrs[]){
        Test test = new Test();
        test.operation();
    }
}

abserver（订阅与发布）

观察者模式（Observer Pattern） —— 定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新。

观察者模式可以理解为发布-订阅模式，即多个订阅者（观察者）向发布者（被观察者）订阅状态信息，当发布者更新状态时会将状态信息向它的订阅者发布信息。发布者需要自己维护订阅者列表，可以注册或者注销对状态信息感兴趣或不感兴趣的订阅者。

state

允许对象在内部状态变化时，变更其行为，并且修改其类