23种设计模式详解（四）

Java大联盟 2018-05-14

257

Java大联盟

致力于最高效的Java学习

1.装饰模式（Decorator Pattern）

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

举例：穿上漂亮的衣服美美的化个妆谁还不是小仙女咋地。

接口：

public interface beBeautiful {
    public void beautiful();
}

华服：

public class hotDresses implements beBeautiful {
    @Override
    public void beautiful() {
        System.out.println("穿上漂亮的衣服");
    }
}

美妆：

public class Cosmetic implements beBeautiful {
    private beBeautiful beautiful;

    public Cosmetic(beBeautiful beautiful) {
        this.beautiful = beautiful;
    }

    @Override
    public void beautiful() {
        System.out.println("画一个美美的妆");
        beautiful.beautiful();
        System.out.println("谁还不是小仙女咋地");

    }
}

秒变小仙女：

public class You {
    public static void main(String[] args){
        beBeautiful be=new hotDresses();
        beBeautiful tt=new Cosmetic(be);
        tt.beautiful();
    }
}

结果：

装饰器模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删）

2.迭代器模式（Iterator Pattern）

迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。

举例：模拟一个集合类的过程。

迭代器接口：

public interface Iterator {
    //前遍历
    public Object previous();
    //后遍历
    public Object next();
    //判断是否有下一个
    public boolean hasNext();
    //取第一个元素
    public Object first();
}

集合接口：

public interface Collection {
    public Iterator iterator();
    //获取集合所有元素
    public Object get(int i);
    //获取集合大小
    public int size();
}

迭代器实现类：

public class myIterator implements Iterator {
    private Collection collection;
    private int num=-1;

    public myIterator(Collection collection) {
        this.collection = collection;
    }

    @Override
    public Object previous() {
        if(num>0){
            num--;
        }
        return collection.get(num);
    }

    @Override
    public Object next() {
        if(num<collection.size()-1){
            num++;
        }
        return collection.get(num);
    }

    @Override
    public boolean hasNext() {
        if(num<collection.size()-1){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public Object first() {
        num=0;
        return collection.get(num);
    }
}

集合实现类：

public class myColllection implements Collection {
    public String string[]={"1","2","3","4","5"};
    @Override
    public Iterator iterator() {
        return new myIterator(this);
    }

    @Override
    public Object get(int i) {
        return string[i];
    }

    @Override
    public int size() {
        return string.length;
    }
}

测试：

public class Test {
    public static void main(String[] args){
        Collection c=new myColllection();
        Iterator i=c.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

结果：

Java.util.Iterable接口只有一个方法就是iterator(),也就是说通过这个方法可以遍历聚集类中的所有方法和属性，基本上所有高级的语言都有Iterator这个接口或者实现，Java已经把迭代器给我们准备了，我们再去写迭代器就有点儿多此一举，所以迭代器模式我们基本不用自己去实现，直接使用List或者Map就可以完整的解决问题。但是我们也必须清楚他的实现过程，这样我们就可以写出自己的集合类，甚至框架！

3.组合模式（Composite Pattern）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。

public class TreeNode{
    private String name;
    private TreeNode parent;
    private Vector<TreeNode> children=new Vector<TreeNode>();
    public TreeNode(String name){
        this.name=name;
    }

    public TreeNode getParent() {
        return parent;
    }

    public void setParent(TreeNode parent) {
        this.parent = parent;
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //添加孩子节点  
    public void add(TreeNode node){
        children.add(node);
    }
    //删除孩子节点
    public void remove(TreeNode node){
        children.remove(node);
    }
    //取得孩子节点
    public Enumeration<TreeNode> etChildren(){
        return children.elements();
    }
}

实现：

public class Tree {
    TreeNode root=null;

    public Tree(String name) {
        root = new TreeNode(name);
    }
    public static void main(String[] args){
        Tree tree=new Tree("A");
        TreeNode nodeB=new TreeNode("B");
        TreeNode nodeC=new TreeNode("C");
        TreeNode nodeD=new TreeNode("D");
        TreeNode nodeE=new TreeNode("E");
        TreeNode nodeF=new TreeNode("#");
        TreeNode nodeG=new TreeNode("#");
        TreeNode nodeH=new TreeNode("#");
        TreeNode nodeI=new TreeNode("#");
        TreeNode nodeJ=new TreeNode("#");
        TreeNode nodeK=new TreeNode("#");
        nodeD.add(nodeF);
        nodeD.add(nodeG);
        nodeE.add(nodeH);
        nodeE.add(nodeI);
        nodeB.add(nodeD);
        nodeB.add(nodeJ);
        nodeC.add(nodeE);
        nodeC.add(nodeK);
        tree.root.add(nodeB);
        tree.root.add(nodeC);

    }
}

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树等。

4.观察者模式（Observer Pattern）

当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

观察者接口：

public interface Observer {
    public void update();
}

第一个观察者：

public class myObserver1 implements Observer{
    @Override
    public void update() {
        System.out.println("myObserver1 has changed");
    }
}

第二个观察者：

public class myObserver2 implements Observer {
    @Override
    public void update() {
        System.out.println("myObserver2 has changed");
    }
}

对象接口：

public interface Subject {
    //增加观察者
    public void add(Observer observer);
    //删除观察者
    public void delete(Observer observer);
    //通知所有观察者
    public void notifyObservers();
    //自己的方法
    public void operation();
}

需要监控的对象列表：

public abstract class AbstractSubject implements Subject {
    private Vector<Observer> vector = new Vector<Observer>();
    @Override
    public void add(Observer observer) {
        vector.add(observer);
    }

    @Override
    public void delete(Observer observer) {
        vector.remove(observer);
    }

    @Override
    public void notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while(enumo.hasMoreElements()){
            enumo.nextElement().update();
        }

    }

}

主对象：

public class mySubject extends AbstractSubject {
    @Override
    public void operation() {
        System.out.println("update self");
        notifyObservers();
    }
}

测试：

public class Test {
    public static void main(String[] args){
        Subject su=new mySubject();
        su.add(new myObserver1());
        su.add(new myObserver2());
        su.operation();
    }
}