聊一聊设计模式（四）-- 行为型设计模式

前言

讲完告终构型设计模式，接下里就是行为型设计模式了。

思惟导图

策略模式

定义一系列的算法，把每个算法封装起来，而且使它们可相互替换。

在初中写关于多边形的题目的时候，咱们可能经过已知方法硬生生解答出来，也有可能用辅助线来帮助咱们解题。这就是两种解题策略。 下面用代码体现一下。

/** * 上下文 * 根据传入策略给出解决方法 */
public class Context {
    private Strategy strategy;
    Context(Strategy strategy){
        this.strategy = strategy;
    }

    void solve(){
        strategy.solve();
    }
}

/** * 两种策略方法 * 1. 辅助线法 * 2. 硬答 */
public class SoftStrategy implements Strategy {
    @Override
    public void solve() {
        System.out.println("辅助线解答");
    }
}

public class HardStrategy implements Strategy {
    @Override
    public void solve() {
        System.out.println("硬生生解答");
    }
}

/** * 抽象策略角色 */
public interface Strategy {
    void solve();
}
复制代码

根据不一样的策略往上下文角色里传入对象，就能获得具体的实现方法。

模版方法模式

定义一个操做中的算法框架，而将一些步骤延迟到子类中，使得子类不改变一个算法的结构便可重定义算法的某些特定步骤。

模版方法模式中的角色：

1. AbstractClass：抽象类，定义框架。
2. ConcreteClass：具体实现类

/** * 模版抽象类 * 定义了一套逻辑方法，而子类只负责继承和完善。 */
public abstract class AbstractPerson {
    public final void wakeup(){
        zhengyan();
        xianbeizi();
        qichuang();
        hook();
    }

    abstract void zhengyan();
    abstract void xianbeizi();
    abstract void qichuang();
    void hook(){}
}

/** * 具体实现类 */
public class Me extends AbstractPerson {
    @Override
    void zhengyan() {
        System.out.println("睁开眼睛");
    }

    @Override
    void xianbeizi() {
        System.out.println("掀被子");
    }

    @Override
    void qichuang() {
        System.out.println("起床");
    }

    @Override
    void hook() {
        super.hook();
        System.out.println("又想睡了");
    }
}
复制代码

hook()方法，称为钩子方法，两种实现方式。

1. 在抽象类中是一个空函数，子类视状况进行覆盖操做。
2. 以boolean做为返回值的，对某个条件进行断定。

观察者模式

定义对象间一种一对多的依赖关系，每当一个对象改变状态时，则全部依赖于它的对象都会获得通知并被自动更新。

该模式中的角色：

1. Subject：抽象主题
2. ConcreteSubject：具体主题。
3. Observer：抽象观察者。
4. ConcreteObserver：具体观察者。

/** * 抽象观察者类 */
public interface IObserver {
    void update(String message);
}

/** * 抽象主题类 */
public interface ISubject {
    void add(IObserver observer);
    void remove(IObserver observer);
    void notify(String message);
}

/** * 具体观察者类 */
public class Observer implements IObserver {
    @Override
    public void update(String message) {
        System.out.println(message);
    }
}

/** * 具体主题类 */
public class Subject implements ISubject {
    List<IObserver> list = new ArrayList<>();

    @Override
    public void add(IObserver observer) {
        list.add(observer);
    }

    @Override
    public void remove(IObserver observer) {
        list.remove(observer);
    }

    @Override
    public void notify(String message) {
        for(IObserver observer: list){
            observer.update(message);
        }
    }
}
复制代码

这个模式听着优势奇怪，可是代码写起来其实一点都不生疏。其实就是使用主题类保存各个观察者，出现变化的话就循环遍历，慢慢通知。

这个模式在个人Android工具包的Network包中也有使用。

可是这个模式存在一个缺点，由于它是一个个进行通知的，那么update()函数中是可能存在耗时操做的。这个时候，比较建议的就是开一个子线程去进行处理，这样在Android中不会对UI线程产生过多的占用。

以上就是个人学习成果，若是有什么我没有思考到的地方或是文章内存在错误，欢迎与我分享。

---

相关文章推荐：

聊一聊设计模式（一）-- 六大原则

聊一聊设计模式（二）-- 建立型设计模式

聊一聊设计模式（三）-- 结构型行为型设计模式