写在后面

• 记录学习设计模式的笔记
• 进步对设计模式的灵活运用

学习地址

https://www.bilibili.com/vide…

https://www.bilibili.com/vide…

参考文章

http://c.biancheng.net/view/1…

我的项目源码
https://gitee.com/zhuang-kang/DesignPattern

24，解释器模式

设计一个软件用来进行加减计算。咱们第一想法就是应用工具类，提供对应的加法和减法的工具办法。

// 用于两个整数相加
public static int add(int a,int b){return a + b;}

// 用于两个整数相加
public static int add(int a,int b,int c){return a + b + c;}

// 用于 n 个整数相加
public static int add(Integer ... arr) {
    int sum = 0;
    for (Integer i : arr) {sum += i;}
    return sum;
}

下面的模式比拟繁多、无限，如果模式变动十分多，这就不符合要求，因为加法和减法运算，两个运算符与数值能够有有限种组合形式。比方 1+2+3+4+5、1+2+3- 4 等等。

显然，当初须要一种翻译辨认机器，可能解析由数字以及 + – 符号形成的非法的运算序列。如果把运算符和数字都看作节点的话，可能一一节点的进行读取解析运算，这就是解释器模式的思维。

24.1 解释器模式的定义和特点

解释器（Interpreter）模式的定义： 给剖析对象定义一个语言，并定义该语言的文法示意，再设计一个解析器来解释语言中的句子。 也就是说，用编译语言的形式来剖析利用中的实例。这种模式实现了文法表达式解决的接口，该接口解释一个特定的上下文。

这里提到的文法和句子的概念同编译原理中的形容雷同，“文法”指语言的语法规定，而“句子”是语言集中的元素。例如，汉语中的句子有很多，“我是中国人”是其中的一个句子，能够用一棵语法树来直观地描述语言中的句子。

解释器模式是一品种行为型模式，其次要长处如下。

1. 扩展性好。因为在解释器模式中应用类来示意语言的文法规定，因而能够通过继承等机制来扭转或扩大文法。
2. 容易实现。在语法树中的每个表达式节点类都是类似的，所以实现其文法较为容易。

解释器模式的次要毛病如下。

1. 执行效率较低。解释器模式中通常应用大量的循环和递归调用，当要解释的句子较简单时，其运行速度很慢，且代码的调试过程也比拟麻烦。
2. 会引起类收缩。解释器模式中的每条规定至多须要定义一个类，当蕴含的文法规定很多时，类的个数将急剧减少，导致系统难以治理与保护。
3. 可利用的场景比拟少。在软件开发中，须要定义语言文法的利用实例非常少，所以这种模式很少被应用到。

24.2 解释器模式的构造与实现

24.2.1 解释器模式的构造

• 形象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，次要蕴含解释办法 interpret()。
• 终结符表达式（Terminal Expression）角色：是形象表达式的子类，用来实现文法中与终结符相干的操作，文法中的每一个终结符都有一个具体终结表达式与之绝对应。
• 非终结符表达式（Nonterminal Expression）角色：也是形象表达式的子类，用来实现文法中与非终结符相干的操作，文法中的每条规定都对应于一个非终结符表达式。
• 环境（Context）角色：通常蕴含各个解释器须要的数据或是公共的性能，个别用来传递被所有解释器共享的数据，前面的解释器能够从这里获取这些值。
• 客户端（Client）：次要工作是将须要剖析的句子或表达式转换成应用解释器对象形容的形象语法树，而后调用解释器的解释办法，当然也能够通过环境角色间接拜访解释器的解释办法。

24.2.2 代码实现

关系类图

AbstractExpression

package com.zhuang.interpreter;

/**
 * @Classname AbstractExpression
 * @Description 形象角色
 * @Date 2021/3/31 9:45
 * @Created by dell
 */

public abstract class AbstractExpression {public abstract int interpret(Context context);
}

Value

package com.zhuang.interpreter;

/**
 * @Classname Value
 * @Description 终结符表达式角色
 * @Date 2021/3/31 9:48
 * @Created by dell
 */

public class Value extends AbstractExpression {

    private int value;

    public Value(int value) {this.value = value;}

    @Override
    public int interpret(Context context) {return value;}

    @Override
    public String toString() {return new Integer(value).toString();}
}

Plus

package com.zhuang.interpreter;

/**
 * @Classname Plus
 * @Description 非终结符表达式角色 加法表达式
 * @Date 2021/3/31 9:46
 * @Created by dell
 */

public class Plus extends AbstractExpression {

    private AbstractExpression left;
    private AbstractExpression right;

    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {return left.interpret(context) + right.interpret(context);
    }

    @Override
    public String toString() {return "(" + left.toString() + "+" + right.toString() + ")";
    }
}

Minus

package com.zhuang.interpreter;

/**
 * @Classname Minus
 * @Description 非终结符表达式角色 减法表达式
 * @Date 2021/3/31 9:46
 * @Created by dell
 */

public class Minus extends AbstractExpression {
    private AbstractExpression left;
    private AbstractExpression right;

    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {return left.interpret(context) - right.interpret(context);
    }

    @Override
    public String toString() {return "(" + left.toString() + "-" + right.toString() + ")";
    }
}

Variable

package com.zhuang.interpreter;

/**
 * @Classname Variable
 * @Description 终结符表达式角色 变量表达式
 * @Date 2021/3/31 9:46
 * @Created by dell
 */

public class Variable extends AbstractExpression {

    private String name;

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

    @Override
    public int interpret(Context context) {return context.getValue(this);
    }

    @Override
    public String toString() {return name;}
}

Context

package com.zhuang.interpreter;

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

/**
 * @Classname Context
 * @Description 环境类
 * @Date 2021/3/31 9:46
 * @Created by dell
 */

public class Context {private Map<Variable, Integer> map = new HashMap<Variable, Integer>();

    public void assign(Variable var, Integer value) {map.put(var, value);
    }

    public int getValue(Variable var) {Integer value = map.get(var);
        return value;
    }
}

Client

package com.zhuang.interpreter;

/**
 * @Classname Client
 * @Description 解释权模式 测试类
 * @Date 2021/3/31 9:46
 * @Created by dell
 */

public class Client {public static void main(String[] args) {Context context = new Context();

        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");
        Variable d = new Variable("d");
        Variable e = new Variable("e");

        context.assign(a, 2);
        context.assign(b, 3);
        context.assign(c, 4);
        context.assign(d, 5);
        context.assign(e, 6);

        AbstractExpression expression = new Minus(new Plus(new Plus(new Plus(a, b), c), d), e);

        System.out.println(expression + "=" + expression.interpret(context));
    }
}

24.3 解释器模式应用场景

• 当语言的文法较为简单，且执行效率不是关键问题时。
• 当问题反复呈现，且能够用一种简略的语言来进行表白时。
• 当一个语言须要解释执行，并且语言中的句子能够示意为一个形象语法树的时候。

25，状态模式

25.1 状态模式的定义和特点

状态（State）模式的定义： 对有状态的对象，把简单的“判断逻辑”提取到不同的状态对象中，容许状态对象在其外部状态产生扭转时扭转其行为。

状态模式是一种对象行为型模式，其次要长处如下。

1. 构造清晰，状态模式将与特定状态相干的行为部分化到一个状态中，并且将不同状态的行为宰割开来，满足“繁多职责准则”。
2. 将状态转换显示化，缩小对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且缩小对象间的相互依赖。
3. 状态类职责明确，有利于程序的扩大。通过定义新的子类很容易地减少新的状态和转换。

状态模式的次要毛病如下。

1. 状态模式的应用必然会减少零碎的类与对象的个数。
2. 状态模式的构造与实现都较为简单，如果使用不当会导致程序结构和代码的凌乱。
3. 状态模式对开闭准则的反对并不太好，对于能够切换状态的状态模式，减少新的状态类须要批改那些负责状态转换的源码，否则无奈切换到新增状态，而且批改某个状态类的行为也须要批改对应类的源码。

25.2 状态模式的构造与实现

【例】通过按钮来管制一个电梯的状态，一个电梯有开门状态，关门状态，进行状态，运行状态。每一种状态扭转，都有可能要依据其余状态来更新解决。例如，如果电梯门当初处于运行时状态，就不能进行开门操作，而如果电梯门是进行状态，就能够执行开门操作

public interface ILift {
    // 电梯的 4 个状态
    // 开门状态
    public final static int OPENING_STATE = 1;
    // 关门状态
    public final static int CLOSING_STATE = 2;
    // 运行状态
    public final static int RUNNING_STATE = 3;
    // 进行状态
    public final static int STOPPING_STATE = 4;

    // 设置电梯的状态
    public void setState(int state);

    // 电梯的动作
    public void open();
    public void close();
    public void run();
    public void stop();}

public class Lift implements ILift {
    private int state;

    @Override
    public void setState(int state) {this.state = state;}

    // 执行关门动作
    @Override
    public void close() {switch (this.state) {
            case OPENING_STATE:
                System.out.println("电梯关门了。。。");// 只有开门状态能够敞开电梯门，能够对应电梯状态表来看
                this.setState(CLOSING_STATE);// 关门之后电梯就是敞开状态了
                break;
            case CLOSING_STATE:
                //do nothing // 曾经是关门状态，不能关门
                break;
            case RUNNING_STATE:
                //do nothing // 运行时电梯门是关着的，不能关门
                break;
            case STOPPING_STATE:
                //do nothing // 进行时电梯也是关着的，不能关门
                break;
        }
    }

    // 执行开门动作
    @Override
    public void open() {switch (this.state) {
            case OPENING_STATE:// 门曾经开了，不能再开门了
                //do nothing
                break;
            case CLOSING_STATE:// 关门状态，门关上:
                System.out.println("电梯门关上了。。。");
                this.setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                //do nothing 运行时电梯不能开门
                break;
            case STOPPING_STATE:
                System.out.println("电梯门开了。。。");// 电梯停了，能够开门了
                this.setState(OPENING_STATE);
                break;
        }
    }

    // 执行运行动作
    @Override
    public void run() {switch (this.state) {
            case OPENING_STATE:// 电梯不能开着门就走
                //do nothing
                break;
            case CLOSING_STATE:// 门关了，能够运行了
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);// 当初是运行状态
                break;
            case RUNNING_STATE:
                //do nothing 曾经是运行状态了
                break;
            case STOPPING_STATE:
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);
                break;
        }
    }

    // 执行进行动作
    @Override
    public void stop() {switch (this.state) {case OPENING_STATE: // 开门的电梯曾经是是进行的了 ( 失常状况下)
                //do nothing
                break;
            case CLOSING_STATE:// 关门时才能够进行
                System.out.println("电梯进行了。。。");
                this.setState(STOPPING_STATE);
                break;
            case RUNNING_STATE:// 运行时当然能够进行了
                System.out.println("电梯进行了。。。");
                this.setState(STOPPING_STATE);
                break;
            case STOPPING_STATE:
                //do nothing
                break;
        }
    }
}

public class Client {public static void main(String[] args) {Lift lift = new Lift();
        lift.setState(ILift.STOPPING_STATE);// 电梯是进行的
        lift.open();// 开门
        lift.close();// 关门
        lift.run();// 运行
        lift.stop();// 进行}
}

问题剖析

• 应用了大量的 switch…case 这样的判断（if…else 也是一样 )，使程序的可浏览性变差。
• 扩展性很差。如果新加了断电的状态，咱们须要批改下面判断逻辑

25.2.1 状态模式的构造

• 环境（Context）角色：也称为上下文，它定义了客户程序须要的接口，保护一个以后状态，并将与状态相干的操作委托给以后状态对象来解决。
• 形象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
• 具体状态（Concrete State）角色：实现形象状态所对应的行为。

25.2.2 代码实现

关系类图

LiftState

package com.zhuang.state.after;

/**
 * @Classname LiftState
 * @Description 形象状态类
 * @Date 2021/3/31 10:50
 * @Created by dell
 */

public abstract class LiftState {
    // 定义一个环境角色，也就是封装状态的变动引起的性能变动
    protected Context context;

    public void setContext(Context context) {this.context = context;}

    // 电梯开门动作
    public abstract void open();

    // 电梯关门动作
    public abstract void close();

    // 电梯运行动作
    public abstract void run();

    // 电梯进行动作
    public abstract void stop();}

Context

package com.zhuang.state.after;

/**
 * @Classname Context
 * @Description 定义所有电梯门状态
 * @Date 2021/3/31 10:53
 * @Created by dell
 */

public class Context {
    // 定义出所有的电梯状态
    // 开门状态，这时候电梯只能敞开
    public final static OpeningState OPENNING_STATE = new OpeningState();
    // 敞开状态，这时候电梯能够运行、进行和开门
    public final static ClosingState CLOSEING_STATE = new ClosingState();
    // 运行状态，这时候电梯只能进行
    public final static RunningState RUNNING_STATE = new RunningState();
    // 进行状态，这时候电梯能够开门、运行
    public final static StoppingState STOPPING_STATE = new StoppingState();


    // 定义一个以后电梯状态
    private LiftState liftState;

    public LiftState getLiftState() {return this.liftState;}

    public void setLiftState(LiftState liftState) {
        // 以后环境扭转
        this.liftState = liftState;
        // 把以后的环境告诉到各个实现类中
        this.liftState.setContext(this);
    }

    public void open() {this.liftState.open();
    }

    public void close() {this.liftState.close();
    }

    public void run() {this.liftState.run();
    }

    public void stop() {this.liftState.stop();
    }
}

OpeningState

package com.zhuang.state.after;

/**
 * @Classname OpeningState
 * @Description 开启状态
 * @Date 2021/3/31 10:51
 * @Created by dell
 */

public class OpeningState extends LiftState {


    // 开启当然能够敞开了，我就想测试一下电梯门开关性能
    @Override
    public void open() {System.out.println("电梯门开启...");
    }

    @Override
    public void close() {
        // 状态批改
        super.context.setLiftState(Context.CLOSEING_STATE);
        // 动作委托为 CloseState 来执行，也就是委托给了 ClosingState 子类执行这个动作
        super.context.getLiftState().close();

    }

    // 电梯门不能开着就跑，这里什么也不做
    @Override
    public void run() {//do nothing}

    // 开门状态曾经是进行的了
    @Override
    public void stop() {//do nothing}
}

ClosingState

package com.zhuang.state.after;

/**
 * @Classname ClosingState
 * @Description 敞开状态
 * @Date 2021/3/31 10:52
 * @Created by dell
 */

public class ClosingState extends LiftState {
    @Override
    // 电梯门敞开，这是敞开状态要实现的动作
    public void close() {System.out.println("电梯门敞开...");
    }

    // 电梯门关了再关上，逗你玩呢，那这个容许呀
    @Override
    public void open() {super.context.setLiftState(Context.OPENNING_STATE);
        super.context.open();}


    // 电梯门关了就跑，这是再失常不过了
    @Override
    public void run() {super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();}

    // 电梯门关着，我就不按楼层
    @Override
    public void stop() {super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();}
}

RunningState

package com.zhuang.state.after;

/**
 * @Classname RunningState
 * @Description 运行状态
 * @Date 2021/3/31 10:52
 * @Created by dell
 */

public class RunningState extends LiftState {

    @Override
    public void open() {// 什么也不做}

    @Override
    public void close() {// 什么也不做}

    @Override
    public void run() {System.out.println("电梯正在运行...");
    }

    @Override
    public void stop() {
        // 进行
        super.context.setLiftState(Context.OPENNING_STATE);
        super.context.stop();}
}

StoppingState

package com.zhuang.state.after;

/**
 * @Classname StoppingState
 * @Description 进行状态
 * @Date 2021/3/31 10:51
 * @Created by dell
 */

public class StoppingState extends LiftState {

    @Override
    public void open() {
        // 状态批改
        super.context.setLiftState(Context.OPENNING_STATE);
        // 动作委托给 CloseState 来执行 也就是委托给了 ClosingState 子类执行动作
        super.context.getLiftState().open();
    }

    @Override
    public void close() {
        // 状态批改
        super.context.setLiftState(Context.CLOSEING_STATE);
        // 动作委托给 CloseState 来执行 也就是委托给了 ClosingState 子类执行动作
        super.context.getLiftState().close();
    }

    @Override
    public void run() {
        // 状态批改
        super.context.setLiftState(Context.RUNNING_STATE);
        // 动作委托给 CloseState 来执行 也就是委托给了 ClosingState 子类执行动作
        super.context.getLiftState().run();
    }

    @Override
    public void stop() {System.out.println("电梯进行了...");
    }
}

Client

package com.zhuang.state.after;

/**
 * @Classname Client
 * @Description 状态模式 测试类
 * @Date 2021/3/31 10:53
 * @Created by dell
 */

public class Client {public static void main(String[] args) {
        // 开门状态
        System.out.println("开门状态 -->");
        Context context1 = new Context();
        context1.setLiftState(new OpeningState());
        context1.open();
        context1.close();
        context1.run();
        context1.stop();

        System.out.println("=========================");
        // 关门状态
        System.out.println("关门状态 -->");
        Context context2 = new Context();
        context2.setLiftState(new ClosingState());
        context2.open();
        context2.close();
        context2.run();
        context2.stop();

        System.out.println("=========================");
        // 运行状态
        System.out.println("运行状态 -->");
        Context context3 = new Context();
        context3.setLiftState(new RunningState());
        context3.open();
        context3.close();
        context3.run();
        context3.stop();

        System.out.println("=========================");
        // 进行状态
        System.out.println("进行状态 -->");
        Context context4 = new Context();
        context4.setLiftState(new StoppingState());
        context4.open();
        context4.close();
        context4.run();
        context4.stop();}
}

25.3 状态模式利用场景

• 当一个对象的行为取决于它的状态，并且它必须在运行时依据状态扭转它的行为时，就能够思考应用状态模式。
• 一个操作中含有宏大的分支构造，并且这些分支决定于对象的状态时。

写在最初

• 如果我的文章对你有用，请给我点个👍，感激你😊！
• 有问题，欢送在评论区指出！💪