设计模式系列：行为型设计模式

行为型模式（11种）：

策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、

备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

 

什么是行为模式：

行为模式就是封装一段操作，例如策略模式，只用在方法中传入参数1和2，可以得出3，也可以得出2，这之中操作就是行为

 

推荐学习思路：

学习行为型设计模式，首先学习策略模式，有助于后面其他设计模式的学习！！

 

策略模式

对某一行为进行抽象化
public interface Handle {
    int doSomething(int a,int b);
}
具体化的内容是策略的具象
public class Say1 implements Handle{
    @Override
    public int doSomething(int a,int b) {
        return (a*b);
    }
}
public class Say2 implements Handle{
    @Override
    public int doSomething(int a,int b) {
        return (a+b);
    }
}
对行为进行封装
这段代码和简单代理模式很像，讲解下其中的困惑点

简单代理模式中，代理类知道被代理类的行为，
因为代理类与被代理类 *实现同一个接口*，因此代理类与被代理类的结构是相同的；
 
而策略模式中，策略容器并不知道内部策略的详细信息，
因为容器并没有实现与内部策略相同的接口，即容器与内部策略只是简单的组合关系，
容器只是将内部策略的行为抽取出来，进行了统一的实现
public class HandleStrategy {
    private Handle h;
    private HandleStrategy() {}
    public HandleStrategy(Handle h) {
        this.h = h;
    }
    public int doSomething(int a,int b) {
        h.doSomething(a+b);
    }
}
调用
public class DoMain {
    public static void main(String[] args) {
        HandleStrategy hs1 = new HandleStrategy(new Say1());
        hs1.doSomething(1,1);
		
        HandleStrategy hs2 = new HandleStrategy(new Say2());
        hs2.doSomething(1,1);
    }
}

 

模板方法模式

建立一个模板
public abstract class Game {
    public abstract  void doSomething1();
    public abstract  void doSomething2();
    public abstract  void doSomething3();
    这里定义了模板，final修饰是关键
    public final void doSomethings() {
        doSomething1();
        doSomething2();
        doSomething3();
    };
}
模板实现
public class SayGame extends Game{
    public void doSomething1() {
        System.out.println("1");
    }
    public void doSomething2() {
        System.out.println("2");
    }
    public void doSomething3() {
        System.out.println("3");
    }
}
调用
public class DoMain {
    public static void main(String[] args) {
        Game g = new SayGame();
        g.doSomethings();
    }
}

 

备忘录模式

*** 意图：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态 ***


备忘录模式分为三个部分 ： 状态，操作，状态仓库

状态，就是模拟封装中的状态
状态
public class Status {
    private String status;
    private Status() {}
    public Status(String status) {
        this.status = status;
    }
    public String getStatus() {
        return status;
    }
}

猜测:之所以把操作和仓库解耦分开为两个对象，可能是这块可能有不同形式的重写
    例如这里的status是String类型，其他状态可能是自定义类型，
    如果不解耦每次重写都会重写仓库部分
操作
public class Handle {
    private String status;
    public Handle() {}
    public void setStatus(String status) {
        this.status = status;
    }
    public String getStatus() {
        return status;
    }
    public Status createStatusObj() {
        return new Status(status);
    }
    public String getStatusAttr(Status status) {
        return status.getStatus();
    }
}

状态仓库
public class StatusWarehouse {
    private List<Status> list = null;
    public StatusWarehouse() {
        list = new ArrayList<Status>();
    }
    public void add(Status status) {
        this.list.add(status);
    }
    public String getStatusContentForIndex(Integer i) {
        return this.list.get(i).getStatus();
    }
}

测试
public class DoMain {
    public static void main(String[] args) {
        StatusWarehouse sw = new StatusWarehouse();
        Handle h = new Handle();
        h.setStatus("1");
        sw.add(h.createStatusObj());
        h.setStatus("2");
        sw.add(h.createStatusObj());
        System.out.println(sw.getStatusContentForIndex(0));
        System.out.println(sw.getStatusContentForIndex(1));
    }
}

 

状态模式

*** 意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。 ***


定义状态
public interface Status {
    void setStatus(StatusMap status);
}

具体化状态
public class DoSomethingStatus implements Status{
    public DoSomethingStatus() {}
    @Override
    public void setStatus(StatusMap sMap) {
        this.doSomething();
        sMap.setStatus(this);
    }
    private void doSomething() {
        System.out.println("do something");
    }
    public String toString(){
        return "1";
    }
}

状态容器
public class StatusMap {
    private Status status;
    public StatusMap() {}
    public void setStatus(Status status) {
        this.status = status;
    }
    public Status getStatus() {
        return status;
    }
}

调用
public class DoMain {
    public static void main(String[] args) {
        StatusMap sm = new StatusMap();
        DoSomethingStatus dss = new DoSomethingStatus();
        dss.setStatus(sm);
        System.out.println(sm.getStatus());
    }
}

 

解释器模式

解释器模式，按字面理解就是将一个不懂或者不确定的因素，转换成能明白的因素,
而转换的过程中，受到另一个因素的约束

public interface TestInterface{
    public boolean bool(String str);
}

public class A implements TestInterface{
     
    private String data;

    public A(String data){
        this.data = data;
    }
    // 这步进行解释，但传参不限于String类型，返回类型不限于Boolean
    // 这里方法名称随意写的
    // 比如前台传过来的加密str，通过解释器得到一系列参数等等
    public boolean bool(String context){
        if(context.contains(this.data)){
            return true;
        }
        return false;
    }
   
}
调用
public class DoMain {
    public static void main(String[] args) {
        String str1 = "1";
        String str2 = "21";
        A a = new A(str1);
        System.out.println(a.bool(str2));
    }
}

 

访问者模式

意图：主要将数据结构与数据操作分离。
主要解决：稳定的数据结构和易变的操作耦合问题。


在写示例之前，我有个疑惑的点是：为什么不用策略模式代替这个设计模式
比如数据结构A ，处理类B  ，通过策略模式传参 A数据结构，B类[或者通过path反射]

public interface Business{
    public void visit(Structure s);
}

public interface Structure{
    public void accept(Business b);
}

public class A implements Structure{
    public void accept(Business b){
        b.visit(this);
    }
}
public class B implements Business{
    public void visit(Structure s){
        System.out.println("do something");
    }
}
调用
public class DoMain {
   public static void main(String[] args) {
      Structure s = new A();
      s.accept(new B());
   }
}

 

责任链模式

意图：
    避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿    着这条链传递请求，直到有对象处理它为止。

主要解决：
    职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

ps:责任链 与 模板方法模式很像，但比模板方法多了相互组合这层逻辑


public abstract class Logger{
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger abstractLogger;

    abstract void write(String str);

    public void setNextLogger(Logger logger){
        this.abstractLogger = logger;
    } 

    public void logMessage(int level, String message){
      if(this.level <= level){
         write(message);
      }
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }   

}

public class AdminA extends Logger{
    
    public AdminA(int level){
        this.level = level;
    }
    
    public void write(String str){
        System.out.println("adminA");
    }
}

public class AdminB extends Logger{
    
    public AdminA(int level){
        this.level = level;
    }
    
    public void write(String str){
        System.out.println("adminB");
    }
}

调用
public class DoMain{
    public static void main(String[] args) {
        Logger a = new AdminA(Logger.INFO);
        Logger b = new AdminB(Logger.DEBUG);
        a.setNextLogger(b);
        a.logMessage(Logger.ERROR,"something");
    }
}

 

观察者模式

public class Handle{
    
    List<InterfaceTest> list = new ArrayList<InterfaceTest>();
    protected int status;
    
    public void getStatus(){
        return status;
    }
    public void setStatus(int status){
        this.status = status;
        this.notifyAllObservers();
    }
    public void add(InterfaceTest test){
        list.add(test);
    }
    public void notifyAllObservers(){
        for(InterfaceTest test : list){
            test.upStatusHandle();
        }
    } 
   
}

public abstract class InterfaceTest{
    private Handle handle;
    public abstract void upStatusHandle();
}

public class TestBusi extends InterfaceTest{
    public TestBusi(Handle handle){
        this.handle = handle;
        this.handle.add(this);
    }
    public void upStatusHandle(){
        System.out.println('TestBusi,'+handle.getStatus());
    }
}

调用
public class DoMain{
    public static void main(String[] args){
        Handle h = new Handle();
        new TestBusi(h);
        h.setStatus(1);
    }
}

待补充