设计模式 概念整理2 行为关系类模式

11种

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

父与子关系

策略模式

设计一个接口，定义通用方法，多个子类实现该接口。

public interface ICalculator {  
    public int calculate(String exp);  
} 
public class Plus extends AbstractCalculator implements ICalculator {  
  
    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"\\+");  
        return arrayInt[0]+arrayInt[1];  
    }  
}  
public class Minus extends AbstractCalculator implements ICalculator {  
  
    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"-");  
        return arrayInt[0]-arrayInt[1];  
    }  
  
}  

策略模式的决定权在用户。

模板方法模式？

观察者模式

当一个对象变化时，其他依赖该对象的对象就会收到通知。
观察者继承观察者接口，实现更新方法，当依赖的对象更新时，调用观察者列表执行更新方法

public interface Observer {  
    public void update();  
}  
public class Observer1 implements Observer {    
    @Override  
    public void update() {  
        System.out.println("observer1 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();  
    }  
}  

迭代子模式

顺序访问集合中的，包含两层意思：1.遍历的对象，2.迭代器对象。

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() {  
        if(pos<collection.size()-1){  
            return true;  
        }else{  
            return false;  
        }  
    }  
    @Override  
    public Object first() {  
        pos = 0;  
        return collection.get(pos);  
    }  
}