GOF23之解释器模式

一、核心作用：

给定一个语言，定义他的文本表示方式，定义一个解释器，解释器使用表示解释语言的句子

二、常见应用场景：

1、正则表达式
2、运算符表达式

三、解释器模式的实现：

环境角色（Context）：包含解释器之外的全局信息
抽象表达式（AbstractExpression）：声明抽象解释操作
真实表达式（ContreteExpression）:实现抽象表达式的操作

四、代码示例：

一、环境角色：

package com.hezeu.Interpreter;

/**
* @Classname Context
* @Description 环境角色
* @Date 2020/2/26 下午 05:52
* @Created by 朱进博 [email protected]
*/
public class Context {
        private String input;
        private String output;

        public String getInput() {
                return input;
        }

        public void setInput(String input) {
                this.input = input;
        }

        public String getOutput() {
                return output;
        }

        public void setOutput(String output) {
                this.output = output;
        }
}

#####二、抽象表达式：

package com.hezeu.Interpreter;

/**
* @Classname AbstractExpression
* @Description 具体命令类
* @Date 2020/2/26 下午 05:53
* @Created by 朱进博 [email protected]
*/
public abstract class AbstractExpression {
        public abstract void Interpret(Context context);
}

三、具体抽象类：

package com.hezeu.command;

/**
* @Classname Invoke
* @Description 调用者
* @Date 2020/2/26 下午 01:19
* @Created by 朱进博 [email protected]
*/
public class Invoke {
        private Command command;

        public Invoke(Command command) {
                this.command = command;
        }

        public void call(){
                command.execute();
        }
}

四、Receiver接收者类类

package com.hezeu.iterator;

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

/**
* @Classname ConcreteAggregate
* @Description TODO
* @Date 2020/2/25 下午 07:34
* @Created by 朱进博 [email protected]
*/
public class ConcreteAggregate implements Aggregate{
        private List<Object> list = new ArrayList<>();

        public void addObject(Object obj) {
                this.list.add(obj);
        }

        public void removeObject(Object obj) {
                this.list.remove(obj);
        }

        public List<Object> getList() {
                return list;
        }

        public void setList(List<Object> list) {
                this.list = list;
        }

        public MyInteger createIterator() {
                return new ConcreteIterator(list);
        }
}

五、解释器模式的优缺点:

优点： 有较强的扩展性

缺点： 解释器模式会引起类膨胀 解释器模式采用递归调用方法，将导致调试复杂 效率低

感谢阅读，水平有限，如有错漏，还请不吝赐教