观察者模式（Observer）--迭代器模式（Iterator）

15、观察者模式（Observer）

包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承。

当你订阅了该文章，如果后续有更新，会及时通知你。对象之间是一种一对多的关系。

MySubject类就是被观察者。

public interface Observer {  

    public void update();  

}  

public class Observer1 implements Observer {  

    @Override  

    public void update() {  

        System.out.println("observer1 has received!");  

    }  

}  

public class Observer2 implements Observer {  

    @Override  

    public void update() {  

        System.out.println("observer2 has received!");  

    }  

}  

public interface Subject {  

    /*增加观察者*/  

    public void add(Observer observer);  

    /*删除观察者*/  

    public void del(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 del(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 ObserverTest {  

    public static void main(String[] args) {  

        Subject sub = new MySubject();  

        sub.add(new Observer1());  

        sub.add(new Observer2());  

        sub.operation();  

    }  

}  

16、迭代器模式（Iterator）

迭代器模式就是顺序访问聚集中的对象

public interface Collection {  

    public Iterator iterator();  

    /*取得集合元素*/  

    public Object get(int i);  

    /*取得集合大小*/  

    public int size();  

}  

public interface Iterator {  

    //前移  

    public Object previous();  

    //后移  

    public Object next();  

    public boolean hasNext();  

    //取得第一个元素  

    public Object first();  

}  

public class MyCollection implements Collection {  

    public String string[] = {"A","B","C","D","E"};  

    @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 MyIterator implements Iterator {  

    private Collection collection;  

    private int pos = -1;  

    public MyIterator(Collection collection){  

        this.collection = collection;  

    }  

    @Override  

    public Object previous() {  

        if(pos > 0){  

            pos--;  

        }  

        return collection.get(pos);  

    }  

    @Override  

    public Object next() {  

        if(pos<collection.size()-1){  

            pos++;  

        }  

        return collection.get(pos);  

    }  

    @Override  

    public boolean hasNext() {  

        return pos<collection.size()-1; 

    }  

    @Override  

    public Object first() {  

        pos = 0;  

        return collection.get(pos);  

    }  

}  

public class Test {  

    public static void main(String[] args) {  

        Collection collection = new MyCollection();  

        Iterator it = collection.iterator();  

        while(it.hasNext()){  

            System.out.println(it.next());  

        }  

    }  

}