行为型设计模式

1.策略模式

1.1定义 ：定义一系列算法，把每个算法封装起来，使得他们可以互相替代

1.2代码实现

定义一个共同接口

public interface FightingStrategy {
    public void fighting();
}

对不同的场景实现接口实现不同的方法

public class CommonRivalStrategy implements  FightingStrategy {
    @Override
    public void fighting() {
        System.out.print("遇到了一般对手，使用圣火令");
    }
}

public class StrongRivalStrategy implements FightingStrategy {
    @Override
    public void fighting() {
        System.out.print("遇到了很菜对手，使用乾坤大挪移");
    }
}

public class WeakRivalStrategy implements  FightingStrategy {
    @Override
    public void fighting() {
        System.out.print("遇到了很菜对手，使用太极剑");
    }
}

策略使用者

public class ZhangWuji {
    private FightingStrategy fightingStrategy;

    public ZhangWuji(FightingStrategy fightingStrategy) {
        this.fightingStrategy = fightingStrategy;
    }
   public void fighting() {
        fightingStrategy.fighting();
    }
}

针对不同的人使用不同的策略

public class Client {
    Client(){
        ZhangWuji zhangWuji = new ZhangWuji(new WeakRivalStrategy());
        zhangWuji.fighting();

        ZhangWuji zhangWuji1 = new ZhangWuji(new CommonRivalStrategy());
        zhangWuji1.fighting();

        ZhangWuji zhangWuji2= new ZhangWuji(new StrongRivalStrategy());
        zhangWuji2.fighting();
    }
}

1.3使用场景及优缺点

1.3.1使用场景

对客户隐藏具体实现细节，完全独立

针对同一个问题的多种处理方式，仅仅是具体行为有差别

1.3.2优点

使用策略模式可以避免多种条件语句

容易扩展，添加一个策略只需要实现一个接口

1.3.3 缺点

每个策略都是一个类，复用性小，策略过多，类的数量会多

1.4 总结

使用策略模式就是定义一个借口，定义很多个策略类，一个判断使用是策略的类，传入不同的策略，调用不同策略的方法效果不一样

2.模板方法模式

定义一个操作中的框架，将这些步骤延迟到子类中，使得子类不改变一个算法结构就可以定义算法的某些特定步骤

2.1 代码实现

定义一个人需要使用一个招式需要的框架

public abstract class AbstractSwordman {

    public final void fighting() {
        //运行内功
        neigong();
        //运行筋脉
        meridian();
        //如果有武器使用
        if (hasWeapons()) {
            weapons();
        }
        //招式
        moves();
        //钩子方法
        hook();
    }

    protected abstract void moves();


    protected boolean hasWeapons() {

        return true;
    }

    protected abstract void weapons();

    protected abstract void meridian();


    protected abstract void neigong();


    protected void hook() {

    }


}

一个人如果需要使用招式就会继承AbstractSwordman 实现抽象方法，

public class zhangSanFeng extends AbstractSwordman {
    final String TAG = "ZhangWuJi";
    @Override
    protected void moves() {
        Log.i(TAG, "使用太极剑");
    }
    @Override
    protected void weapons() {
        Log.i(TAG, "使用真武剑");
    }
    @Override
    protected void meridian() {
        Log.i(TAG, "开启筋脉");
    }
    @Override
    protected void neigong() {
        Log.i(TAG, "使用九阳神功");
    }
}

public class ZhangWuJi extends AbstractSwordman {
    final String TAG = "ZhangWuJi";
    @Override
    protected void moves() {
        Log.i(TAG, "使用乾坤大挪移");
    }
    @Override
    protected void weapons() {
    }
    @Override
    protected void meridian() {
        Log.i(TAG, "开启筋脉");
    }
    @Override
    protected void neigong() {
        Log.i(TAG, "运行九阳神功");
    }
    @Override
    protected boolean hasWeapons() {
        return false;
    }
}

当调用对象方法的时候，抽象类就会去执行子类的方法实现，拼接成一个真正的实现。

public class Client {
    Client() {
        zhangSanFeng zhangSanFeng = new zhangSanFeng();
        zhangSanFeng.fighting();
        ZhangWuJi zhangWuJi = new ZhangWuJi();
        zhangWuJi.fighting();
    }

}

2.2 使用场景及优缺点

2.2.1使用场景

多个子类有共同的方法，并且逻辑基本相同

面对重要，复杂算法，可以把核心算法设计为模板方法，周边相关细节功能由子类实现

需要通过子类来决定父类中某个步骤是否执行，实现子类对父类的反向控制

2.2.2 优点

使用模板方法可以将不变的行为放到超类，去除了子类中重复代码

子类实现算法的某个细节，有助算法扩展

2.3总结

其实模板设计模式可以想到我们的baseActivity 就是抽象父类定义需要的方法，然后让子类去实现具体的细节

3.观察者模式

定义：定义对象之间一种一对多的依赖关系，每当对象改变状态时候，所有依赖他的对象都会被全部得到通知和更新

3.1代码实现

定义一个观察者接口定义观察者有什么被观察的方法

public interface Observer {
    public void update(String message);
}

定义具体观察者对象

import android.util.Log;

public class WeiXinUser implements Observer {

    private static final String TAG = "WeiXinUser";
    private String name;

    public WeiXinUser(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        Log.i(TAG, name + message);
    }



}

抽象被观察者

public interface Subject {
    public void attach(Observer observer);


    void detach(Observer observer);

    void notify(String message);
}

具体实现被观察者

public class SubscriptionSubject implements Subject {
    private List<Observer> weixinUserList = new ArrayList<>();
    @Override
    public void attach(Observer observer) {
        weixinUserList.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        weixinUserList.remove(observer);
    }
    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserList) {
            observer.update(message);
        }
    }
}

具体被观察者和观察的订阅和实现发送消息

public class Client {
    public Client() {
        WeiXinUser zhanwuji = new WeiXinUser("张无忌");
        WeiXinUser qiaofen = new WeiXinUser("乔峰");
        SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
        subscriptionSubject.attach(zhanwuji);
        subscriptionSubject.attach(qiaofen);
        subscriptionSubject.notify("该学习啦");
    }
}

3.2 使用场景和优缺点

3.2.1 使用场景

跨系统的消息交换场景，如消息队列，事件总线的处理机制

事件多级触发场景

3.2.2 优点

观察者和被观察者之间是抽象偶合，容易扩展

方便建立一套触发机制

3.2.3总结

其实订阅者模式就是将观察者将自己放到被观察者里面通过集合存储起来，然后循环调用起来。