Java经典设计模式之十一种行为型模式（附实例和详解）

Java经典设计模式共有21中，分为三大类：创建型模式（5种）、结构型模式（7种）和行为型模式（11种）。

本文主要讲行为型模式，创建型模式和结构型模式可以看博主的另外两篇文章：Java经典设计模式之五大创建型模式（附实例和详解）、 Java经典设计模式之七大结构型模式（附实例和详解）。

行为型模式细分为如下11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

接下来对11种行为型模式逐个进行介绍。

一、策略模式

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类，视实际需求是否添加），提供辅助函数。

首先统一接口：

package com.model.behaviour;

public interface ICalculator {
    public int calculate(String exp);
}

辅助类：

package com.model.behaviour;

public abstract class AbstractCalculator {

    public int[] split(String exp, String opt) {
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}

三个实现类：

package com.model.behaviour;

public class Plus extends AbstractCalculator implements ICalculator {
   

    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp, "\\+");
        return arrayInt[0] + arrayInt[1];
    }
}

package com.model.behaviour;

public class Minus extends AbstractCalculator implements ICalculator {
   

    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp, "\\-");
        return arrayInt[0] - arrayInt[1];
    }

}

package com.model.behaviour;

public class Multiply extends AbstractCalculator implements ICalculator {
     

    @Override  
    public int calculate(String exp) {  
        int arrayInt[] = split(exp,"\\*");  
        return arrayInt[0]*arrayInt[1];  
    }  
}  

测试类：

package com.model.behaviour;

public class StrategyTest {

    public static void main(String[] args) {
        String exp = "8-2";
        ICalculator cal = new Minus();
        int result = cal.calculate(exp);
        System.out.println(exp + "=" + result);
    }
}

策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

二、模板方法模式

解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1…n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。

就是在AbstractCalculator类中定义一个主方法calculate，calculate()调用spilt()等，Plus和Minus分别继承AbstractCalculator类，通过对AbstractCalculator的调用实现对子类的调用，看下面的例子：

package com.model.behaviour;

public abstract class AbstractCalculator {  

    /*主方法，实现对本类其它方法的调用*/  
    public final int calculate(String exp,String opt){  
        int array[] = split(exp,opt);  
        return calculate(array[0],array[1]);  
    }  

    /*被子类重写的方法*/  
    abstract public int calculate(int num1,int num2);  

    public int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }  
}  

package com.model.behaviour;

public class Plus extends AbstractCalculator {
     

    @Override  
    public int calculate(int num1,int num2) {  
        return num1 + num2;  
    }  
}  

package com.model.behaviour;

public class StrategyTest {  

    public static void main(String[] args) {  
        String exp = "8+8";  
        AbstractCalculator cal = new Plus();  
        int result = cal.calculate(exp, "\\+");  
        System.out.println(result);  
    }  
}  

三、观察者模式

包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承。

观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

package com.model.behaviour;

public interface Observer {  
    public void update();  
}  

package com.model.behaviour;

public class Observer1 implements Observer {
     

    @Override  
    public void update() {  
        System.out.println("observer1 has received!");  
    }  
}  

package com.model.behaviour;

public class Observer2 implements Observer {
     

    @Override  
    public void update() {  
        System.out.println("obser