Android常用的设计模式（三）

观察者模式

1.意图
定义对象间的一种一对多的依赖（观察）关系，当一个对象的状态发生改变时，所有依赖于（观察）它的对象都得到通知并被自动更新。
2.结构

3.代码

public abstract class Subject {
    /**
     * 用来保存注册的观察者对象
     */
    private    List<Observer> list = new ArrayList<Observer>();
    /**
     * 注册观察者对象
     * @param observer    观察者对象
     */
    public void attach(Observer observer){

        list.add(observer);
        System.out.println("Attached an observer");
    }
    /**
     * 删除观察者对象
     * @param observer    观察者对象
     */
    public void detach(Observer observer){

        list.remove(observer);
    }
    /**
     * 通知所有注册的观察者对象
     */
    public void nodifyObservers(String newState){

        for(Observer observer : list){
            observer.update(newState);
        }
    }
}

public class ConcreteSubject extends Subject{

    private String state;

    public String getState() {
        return state;
    }

    public void change(String newState){
        state = newState;
        System.out.println("主题状态为：" + state);
        //状态发生改变，通知各个观察者
        this.nodifyObservers(state);
    }
}

// 观察者接口
public interface Observer {
    /**
     * 更新接口
     * @param state    更新的状态
     */
    public void update(String state);
    //实现这个接口必须实现自己的更新方法
}

public class ConcreteObserver implements Observer {
    //观察者的状态
    private String observerState;

    @Override
    public void update(String state) {
        /**
         * 更新观察者的状态，使其与目标的状态保持一致
         */
        observerState = state;
        System.out.println("状态为："+observerState);
    }

}

//客户端调用
public class Client {

    public static void main(String[] args) {
        //创建主题对象
        ConcreteSubject subject = new ConcreteSubject();
        //创建观察者对象
        Observer observer = new ConcreteObserver();
        //将观察者对象登记到主题对象上
        subject.attach(observer);
        //改变主题对象的状态
        subject.change("new state");
    }

}

4.效果
(1).行为型模式
(2).目标和观察者间的抽象耦合(经典实现)。
(3).支持广播通信(相信这点android开发者看到后应该有启发吧)。
(4).注意意外的更新，这也是观察者更新进行管理的原因之一。

模板方法模式

1.意图
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
2.结构

3.代码

public class View{  
    /**  
     * 钩子操作，空实现  
     */ 
    protected void onDraw(Canvas canvas) {  
    }  

    /**  
     *钩子操作，空实现  
     */ 
    protected void dispatchDraw(Canvas canvas) {  
    }  

    //算法骨架  
    public void draw(Canvas canvas) {  
       if (!verticalEdges && !horizontalEdges) {  
            // 步骤1  
            if (!dirtyOpaque) onDraw(canvas);  

            // 步骤2  
            dispatchDraw(canvas);  

            // 步骤3  
            onDrawScrollBars(canvas);  

            return;  
        }  
    }  
    //... ...  
}  

可以看到View类中定义了基本的算法框架，他的子类自已自行实现自己的各个方法。
4.效果
(1).模板方法是一种代码复用的基本技术。它们在类库中尤为重要，它们提取了类库中的公共行为。
(2).模板方法导致一种方向控制结构,”好莱坞法则”：”Don’t call me,i will call you.”,即一个父类调用子类的操作，而不是相反。
(3).模板调用操作的类型有具体的操作，具体的AbstracClass操作，原语操作，工厂方法，钩子操作。少定义原语操作。
(4).android中对这些重定义操作的命名喜欢在方法前加一个前缀on。
(5).模板方法使用继承来改变算法的一部分。策略模式使用委托来改变整个算法。

总结了8种在Android中常用的8中设计模式。总的设计模式为23种。在以后学习时用到会继续补充。