设计模式之禅笔记3

适配器模式

定义：将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够一起工作。
适配器模式又叫变压器模式，也叫做包装模式。
适配器模式的三个角色：
1. target:目标角色。定义把其他类转换为何种接口，也就是我们的期望接口。
2. Adaptee:原角色。你想把谁转换成目标角色，这个谁就是原角色。它是已经存在的、运行良好的类或对象。经过适配器角色的包装，它会成为一个崭新的角色。
3. Adapter:适配器角色。通过继承或类关联的方式，把原角色转换成目标角色。
通用源码：

public interface Target {    //目标角色有自己的方法    public void request();}public class ConcreteTarget implements Target {    public void request() {        System.out.println("I have nothing to do. if you need any help,pls call me!");  }}public class Adaptee{    //原有的业务逻辑    public void doSomething(){        System.out.println("I'm kind of busy,leave me alone,pls!");    }}public class Adapter extends Adaptee implements Target {    public void request() {        super.doSomething();    }}public class Client {    public static void main(String[] args) {        //原有的业务逻辑        Target target = new ConcreteTarget();        target.request();        //增加了适配器角色之后的业务逻辑        Target target2 = new Adapter();        target2.request();    }}

• 优点：可以让两个没有任何关系的类在一起运行。增加了类的透明性。提高了类的服用度。灵活性非常好。如果某一天不想哟适配器了，删除掉这个适配器就可以了，其他的代码不用修改。
• 使用场景：你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的选择。比如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口，便可以使用适配器模式。
• 注意事项：适配器模式不是为了解决还在开发阶段的问题，而是解决正在服役的项目问题。主要使用场景是扩展应用。而且项目一定要遵守依赖倒置原则和里氏替换原则，否则即使在适合使用适配器的场景下，也会带来非常大的改造。

适配器模式的扩展：
对象适配器。
与上面的类适配器的区别是：类适配器是类间继承，对象适配器是对象的合成关系。也可以说是类的关联关系。对象适配器是通过类间的关联关系进行耦合的，因此比较灵活，比如修补原角色的隐形缺陷，关联其他对象等。而类适配器只能通过复写原角色的方法进行扩展。实际项目中对象适配器用得比较多。

迭代器模式

定义：它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。
注：目前是一个没落的模式，基本没人会单独写一个迭代器，除非是产品性质的开发。
角色：
1. Iterator抽象迭代器：负责定义访问和遍历元素的接口。而且基本上是有固定的3个方法。first()获得第一个元素，next()访问下一个元素，isDone()是否已经访问到底部。
2. ConcreteIterator具体迭代器：实现迭代器接口，完成容器元素的遍历。
3. Aggregate抽象容器：提供创建具体迭代器角色的接口，必然提供一个类似createIterator这样的方法。
4. ConcreteAggregate具体容器：创建出容纳迭代器对象。
通用源码：

public interface Iterator{    public Object next();    public boolean hasNext();    public boolean remove();}public class ConcreteIterator implements Iterator{    private Vector vector = new Vector();    public int crusor = 0;    public ConcreteIterator(Vector _vector){        this.vector = _vector;    }    public boolean hasNext(){        if(this.crusor == this.vector.size()){            return false;        }else{            return true;        }    }    public Object next(){        Object result = null;        if(this.hasNext()){            result = this.vector.get(this.cursor++);        }else{            result = null;        }        return result;    }    public boolean remove(){        this.vector.remove(this.cursor);        return true;    }}public interface Aggregate(){    public void add(Object object);    public void remove(Object object);    public Iterator iterator();}public class ConcreteAggregate implements Aggregate{    private Vecotr vector = new Vector();    public void add(Object object){        this.vector.add(object);    }    public void remove(Object object){        this.vector.remove(object);    }    public Iterator iterator(){        return new ConcreteIterator(this.vector);    }}public class Client {    public static void main(String[] args) {        Aggregate agg = new ConcreteAggregate();        agg.add("abc");        agg.add("aaa");        agg.add("1234");        Iterator iterator = agg.iterator();        while(iterator.hasNext()){            System.out.println(iterator.next());        }    }}

java已经把迭代器写好了。因为有很多容器类。也不用我们再去写迭代器模式了。

组合模式

将对象组合成树形结构以表示“部分–整体”的层次结构，使得用户对单个和组合对象的使用具有一致性。
角色：
1. Component抽象构件角色：定义组合对象的共有方法和属性，可以定义一些 默认的行为或属性。
2. Leaf叶子构件：其下再也没有其他的分支。也就是遍历的最小单位。
3. Composite树枝构件：组合树枝节点和叶子节点形成一个树形结构。
通用源码：

public abstract class Component {    //个体和公体都具有的共享    public void doSomething(){    }}public class Composite extends Component {    //构件容器    private ArrayList<Component> componentArrayList = new ArrayList<Component>();    //增加一个叶子构件或树枝构件    public void add(Component component){        this.componentArrayList.add(component);    }    public void remove(Component component){        this.componentArrayList.remove(component);    }    //获得分支下所有的叶子构件和分支构件    public ArrayList<Component> getChildren(){        return this.componentArrayList;    }}public class Leaf extends Component {    /*     * //可以覆写父类方法     * public void doSomething(){     *      * }     */}public class Client {    public static void main(String[] args) {        Composite root = new Composite();        root.doSomething();        Composite branch = new Composite();        Leaf leaf = new Leaf();        root.add(branch);        branch.add(leaf);           }    public static void display(Composite root){        for(Component c:root.getChildren()){            if(c instanceof Leaf){                 c.doSomething();            }else{                 display((Composite)c);            }        }    }}

优点：
1. 高层模块调用简单。一棵树形结构的所有节点都是Component。局部和整体对调用者来说没有任何区别。高层模块不必关系自己处理的是单个对象还是整个组合结构。
2. 节点自由增加。想增加一个节点只要找到他的父节点就成。非常容易扩展。
缺点：在场景类中的定义中，使用树枝和树叶时直接用了实现类，与依赖倒置原则冲突。
使用场景：
1. 维护和展示部分–整体关系的场景，如树形菜单，文件和文件夹管理等。
2. 从一个整体能够独立出部分模块或功能的场景。