Android与设计模式(2)观察者/备忘录/模板/中介者

详细代码请见https://github.com/zackLangChina/DesignPatternLearning

Android与设计模式(1)
单例模式 ** 工厂模式 ** 策略模式 ** 命令模式
Android与设计模式(2)
观察者模式 ** 备忘录模式 ** 模板方法模式 ** 中介者模式
Android与设计模式(3)
代理模式 ** 适配器模式 ** 装饰模式 ** 享元模式
Android与设计模式(4)
外观模式 ** 桥接模式 ** MVP模式

5，观察者模式

观察者模式

使用场景：

用于1对n的通知。

Android中的应用：

Boardcast广播。

组成部分

观察者接口 | 具体的观察者 | 通知者

代码示例：

import java.util.ArrayList;
import java.util.List;

//通知者
class ObserverPattern {
    private List mObservers = new ArrayList<>();
    //加入观察者
    public void addObserver(IObserver observer) {
        mObservers.add(observer);
    }
    //通知[所有]观察者
    public void notifyObserver() {
        for (IObserver ob : mObservers) {
            ob.callback();
        }
    }
}

//观察者接口
interface IObserver {
    void callback();
}

//具体的观察者
class LaoWang implements IObserver {

    @Override
    public void callback() {
        System.out.println("老王知道了！");
    }
}
//具体的观察者
class ZhangSan implements IObserver {

    @Override
    public void callback() {
        System.out.println("张三知道了！");
    }
}

6，备忘录模式

备忘录模式

使用场景：

用于状态的恢复。

Android中的应用：

Activity切到后台显示时，会通过onSaveInstanceState函数保存状态，恢复显示时可以在onCreate方法中拿到之前的状态进行恢复。

组成部分

要备份状态的对象 | 备忘录 | 状态的控制者

代码示例：

//要备份状态的对象
class MemoPattern {
    private String mWhatToDO;
    private MyMemo mMemo;

    public MemoPattern(String whatToDO) {
        this.mWhatToDO = whatToDO;
    }

    public void setWhatToDO(String whatToDO) {
        this.mWhatToDO = whatToDO;
    }

    public String toString() {
        return mWhatToDO;
    }

    //使用当前状态创建memo
    public MyMemo createMemo() {
        return new MyMemo(mWhatToDO);
    }

    //使用memo恢复状态
    public void restore(MyMemo memo) {
        mWhatToDO = memo.getmWhatToDo();
    }
}

//备忘录，用于存储状态
class MyMemo {
    private String mWhatToDo;

    public MyMemo(String whatToDo) {
        this.mWhatToDo = whatToDo;
    }

    public String getmWhatToDo() {
        return mWhatToDo;
    }
}

7，模板方法模式

模板方法模式

使用场景：

定义一个函数执行流程，子类可以自定义这些函数，使得子类可以不改变一个算法的结构即可重定义该流程中的具体过程。

Android中的应用：

Activity的生命周期中有非常多的函数调用步骤，这就是应用了模板方法模式使得用户可以自定义生命周期中的步骤的具体实现。

组成部分

流程过程中定义函数的抽象类 | 实现类

代码示例：

//定义流程的抽象类
abstract class TempPattern {
    public void templateMethod() {
        firstMethod();
        secondMethod();
        lastMethod();
    }

    abstract protected void firstMethod();
    abstract protected void secondMethod();
    abstract protected void lastMethod();
}

//模板实现类，可以自定义流程中具体做什么
class TempClass extends TempPattern {
    protected void firstMethod() {
        System.out.println("first, do something");
    }
    protected void secondMethod() {
        System.out.println("second, do something");
    }
    protected void lastMethod() {
        System.out.println("last, do something");
    }
}

8，中介者模式

中介者模式

使用场景：

用一个中介者来封装一系列的对象交互，使各对象不需要显式地相互引用（解耦）。
MVC就是中介者模式的应用，控制器（C）就是模型（M）和视图（V）的中介者。

Android中的应用：

Binder驱动就是一个中介，其中保存了所有服务，服务之间交互的话，需要通过Binder驱动。

组成部分

中介者 | 需要通过中介者沟通的类

代码示例：

import java.util.HashMap;
import java.util.Map;

//中介者
class MyMediator {
    private Map mServiceList = new HashMap();
    //加入同事类
    public void addService(String name, IService service) {
        mServiceList.put(name,service);
    }
    //中介调用
    public void invokeService(String name) {
        mServiceList.get(name).receiveCall();
    }
}
//同事类，模仿服务之间相互调用
interface IService {
    void callService(String name);
    void receiveCall();
}
//同事类A,可以调用其他同事类，但不需要耦合其他同事类
class ServiceA implements IService {
    private MyMediator mMediator;

    public ServiceA(MyMediator mMediator) {
        this.mMediator = mMediator;
    }

    @Override
    public void callService(String name) {
        System.out.println("ServiceA callService:" + name);
        mMediator.invokeService(name);
    }

    @Override
    public void receiveCall() {
        System.out.println("ServiceA invoked");
    }
}
//同事类B,可以调用其他同事类，但不需要耦合其他同事类
class ServiceB implements IService {
    private MyMediator mMediator;

    public ServiceB(MyMediator mMediator) {
        this.mMediator = mMediator;
    }

    @Override
    public void callService(String name) {
        System.out.println("ServiceB callService:" + name);
        mMediator.invokeService(name);
    }

    @Override
    public void receiveCall() {
        System.out.println("ServiceB invoked");
    }
}