作者相关推荐

北风设计模式课程---19、解释器模式

一、总结

一句话总结：

不仅要通过视频学，还要看别的博客里面的介绍，搜讲解，搜作用，搜实例

设计模式都是对生活的抽象，比如用户获得装备，我可以先装备工厂先生产出来装备，然后给宗门武器库，宗门武器库发给我，如果是打怪获得的装备，可以是装备工厂把装备给的怪物装备库

1、什么是解释器模式？

简单的语法解释器构架：Interpreter模式是一种简单的语法解释器构架

 Interpreter模式也叫解释器模式，是行为模式之一，它
是一种特殊的设计模式，它建立一个解释器，对于特定
的计算机程序设计语言，用来解释预先定义的文法。简
单地说，Interpreter模式是一种简单的语法解释器构架。

2、解释器模式应用场景？

当有一个语言需要解释执行, 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。

3、解释器模式的角色和职责？

Context：解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等：Context.java

AbstractExpression：解释器抽象类：Expression.java

ConcreteExpression：解释器具体实现类：MinusExpression.java、PlusExpression.java

二、内容在总结中

1、相关知识

Context：解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等：Context.java

AbstractExpression：解释器抽象类：Expression.java

ConcreteExpression：解释器具体实现类：MinusExpression.java、PlusExpression.java

 

2、代码

Context：解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等：Context.java

/*
 * 上下文环境类，用来保存文法
 */
public class Context {
    
    private String input;
    private int output;
    
    public Context(String input) {
        this.input = input;
    }
    
    public String getInput() {
        return input;
    }
    public void setInput(String input) {
        this.input = input;
    }
    public int getOutput() {
        return output;
    }
    public void setOutput(int output) {
        this.output = output;
    }
}

AbstractExpression：解释器抽象类：Expression.java

/*
 * 抽象解释器
 */
public abstract class Expression {
    
    public abstract void interpret(Context context);
    
}

ConcreteExpression：解释器具体实现类：MinusExpression.java、PlusExpression.java

MinusExpression.java

public class MinusExpression extends Expression {

    public void interpret(Context context) {
        System.out.println("×Ô¶¯µÝ¼õ");
        String input = context.getInput();
        int inInput = Integer.parseInt(input);
//        inInput--;
        --inInput;
        context.setInput(String.valueOf(inInput));
        context.setOutput(inInput);
    }

}

PlusExpression.java

public class PlusExpression extends Expression {

    public void interpret(Context context) {
        //提示信息
        System.out.println("自动递增");
        //获得上下文环境
        String input = context.getInput();
        //进行类型转换
        int intInput = Integer.parseInt(input);
        //进行递增
//        intInput++;
        ++intInput;
        //对上下文环境重新进行赋值
        context.setInput(String.valueOf(intInput));
        context.setOutput(intInput);
    }

}

客户端调用

import java.util.ArrayList;
import java.util.List;

/*
 * client
 */
public class MainClass {
    public static void main(String[] args) {
        String number = "20";
        Context context = new Context(number);
        
//        Expression expression1 = new MinusExpression();
//        expression1.interpret(context);
//        System.out.println(context.getOutput());
//        
//        Expression expression2 = new PlusExpression();
//        expression2.interpret(context);
//        System.out.println(context.getOutput());
//        
//        Expression expression3 = new PlusExpression();
//        expression3.interpret(context);
//        System.out.println(context.getOutput());
//        
//        Expression expression4 = new PlusExpression();
//        expression4.interpret(context);
//        System.out.println(context.getOutput());
        
        List<Expression> list = new ArrayList<Expression>();
        list.add(new PlusExpression());
        list.add(new PlusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());
        
        for(Expression ex : list) {
            ex.interpret(context);
            System.out.println(context.getOutput());
        }
    }
}