精华内容
下载资源
问答
  • 解释器模式
    万次阅读
    2021-11-03 17:11:21

    解释器模式,给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。解释器模式解决的问题是,如果一种特定类型的问题发生的频率足够高,那么可能就只得将该问题的各个示例表述为一个简单语言中的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决问题。

    #include <iostream>
    #include <list>
    #include<vector>
    #include<string>
    using namespace std;
    
    class Context
    {
    private:
    	std::string m_strInput;
    	std::string m_strOutput;
    public:
    	void setExpression(std::string str)
    	{
    		m_strInput = str;
    	}
    };
    
    class Expression
    {
    public:
    	virtual void Interpret(Context * context) = 0;
    };
    
    class TerminalExpression : public Expression
    {
    public:
    	void Interpret(Context * context)
    	{
    		std::cout << "TerminalExpression!" << std::endl;
    	}
    };
    
    class NonterminalExpression : public Expression
    {
    public:
    	void Interpret(Context * context)
    	{
    		std::cout << "NonterminalExpression!" << std::endl;
    	}
    };
    
    int main()
    {
    	using namespace std;
    	// 解释器模式
    	Context * pContext = new Context();
    	pContext->setExpression("Expression......");
    	Expression * pNon = new NonterminalExpression();
    	Expression * p = new TerminalExpression();
    	// 根据Expression中的内容判断采用那种表达式解析
    	pNon->Interpret(pContext);
    	p->Interpret(pContext);
    	delete p;
    	delete pNon;
    	delete pContext;
    
    	getchar();
    	return 0;
    }
    
    
    

    在这里插入图片描述

    更多相关内容
  • 主要介绍了Java设计模式之解释器模式(Interpreter模式)介绍,Interpreter定义:定义语言的文法,并且建立一个解释器来解释该语言中的句子,需要的朋友可以参考下
  • 主要介绍了javascript设计模式之解释器模式详解,当有一个语言需要解释执行,并且可以将该语言中的句子表示为一个抽象语法树的时候,可以考虑使用解释器模式,需要的朋友可以参考下
  • 主要介绍了javascript设计模式 – 解释器模式,结合实例形式分析了javascript解释器模式相关概念、原理、用法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Python设计模式之解释器模式原理与用法,结合具体实例形式分析了解释器模式的概念、原理、定义及使用方法,需要的朋友可以参考下
  • 主要介绍了Python设计模式编程中解释器模式的简单程序示例分享,解释器模式强调用抽象类来表达程序中将要实现的功能,需要的朋友可以参考下
  • 本文实例讲述了Android编程设计模式之解释器模式。分享给大家供大家参考,具体如下: 一、介绍 解释器模式(Interpreter Pattern)是一种用的比较少的行为型模式,其提供了一种解释语言的语法或表达式的方式,该模式...
  • java设计模式之解释器模式,自己根据理解还有参考弄的,看不懂的可以细聊
  • 解释器模式 今天和大家分享的模式是解释器模式。 首先介绍一下解释器模式适合解决哪类问题。 其实,解释器模式需要解决的问题是,如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为...
  • 解释器模式

    千次阅读 2019-09-25 20:28:33
    解释器模式(Interpreter Pattern)提供了评估语言的语法或表达式的方式,它属于行为型模式。这种模式实现了一个表达式接口,该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。 介绍 意图:...

    解释器模式(Interpreter Pattern)提供了评估语言的语法或表达式的方式,它属于行为型模式。这种模式实现了一个表达式接口,该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

    介绍

    意图:给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该标识来解释语言中的句子。

    主要解决:对于一些固定文法构建一个解释句子的解释器。

    何时使用:如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。

    如何解决:构建语法树,定义终结符与非终结符。

    关键代码:构建环境类,包含解释器之外的一些全局信息,一般是 HashMap。

    应用实例:编译器、运算表达式计算。

    优点 :1、可扩展性比较好,灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。

    缺点: 1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模式采用递归调用方法。

    使用场景 :1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。

    注意事项:可利用场景比较少,JAVA 中如果碰到可以用 expression4J 代替。

    实现

    我们将创建一个接口 Expression 和实现了 Expression 接口的实体类。定义作为上下文中主要解释器的 TerminalExpression 类。其他的类 OrExpressionAndExpression 用于创建组合式表达式。

    InterpreterPatternDemo,我们的演示类使用 Expression 类创建规则和演示表达式的解析。

    解释器模式

    步骤 1

    创建一个表达式接口。

    Expression.java

    public interface Expression {
    
        boolean interpret(String context);
    
    }
    

    步骤 2

    创建实现了上述接口的实体类。

    TerminalExpression.java

    public class TerminalExpression implements Expression {
    
        private String data;
    
        public TerminalExpression(String data) {
            this.data = data;
        }
    
        @Override
        public boolean interpret(String context) {
            if (context.contains(data)) {
                return true;
            }
    
            return false;
        }
    
    }
    

    OrExpression.java

    public class OrExpression implements Expression {
    
        private Expression expr1 = null;
        private Expression expr2 = null;
    
        public OrExpression(Expression expr1, Expression expr2) {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
    
        @Override
        public boolean interpret(String context) {
            return expr1.interpret(context) || expr2.interpret(context);
        }
    
    }
    

    AndExpression.java

    public class AndExpression implements Expression {
    
        private Expression expr1 = null;
        private Expression expr2 = null;
    
        public AndExpression(Expression expr1, Expression expr2) {
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
    
        @Override
        public boolean interpret(String context) {
            return expr1.interpret(context) && expr2.interpret(context);
        }
    
    }
    

    步骤 3

    InterpreterPatternDemo 使用 Expression 类来创建规则,并解析它们。

    InterpreterPatternDemo.java

    public class InterpreterPatternDemo {
    
        //规则:Robert 和 John 是男性
        public static Expression getMaleExpression(){
            Expression robert = new TerminalExpression("Robert");
            Expression john = new TerminalExpression("John");
            return new OrExpression(robert, john);
        }
    
        //规则:Julie 是一个已婚的女性
        public static Expression getMarriedWomanExpression(){
            Expression julie = new TerminalExpression("Julie");
            Expression married = new TerminalExpression("Married");
            return new AndExpression(julie, married);
        }
    
        public static void main(String[] args) {
            Expression isMale = getMaleExpression();
            Expression isMarriedWoman = getMarriedWomanExpression();
    
            System.out.println("John is male? " + isMale.interpret("John"));
            System.out.println("Julie is a married women? "
                    + isMarriedWoman.interpret("Married Julie"));
        }
    
    }
    

    步骤 4

    验证输出。

    John is male? true
    Julie is a married women? true
    
    展开全文
  • 设计模式之解释器模式的Java版本实现和UML类图设计
  • 解释器模式原理及其在JDK源码中的体现设计模式系列汇总前言什么是解释器模式终结符表达式和非终结符表达式解释器模式示例解释器模式角色解释器模式在JDK和Spring源码中应用解释器模式应用场景解释器模式优缺点总结 ...

    设计模式系列总览

    设计模式飞机票
    三大工厂模式登机入口
    策略模式登机入口
    委派模式登机入口
    模板方法模式登机入口
    观察者模式登机入口
    单例模式登机入口
    原型模式登机入口
    代理模式登机入口
    装饰者模式登机入口
    适配器模式登机入口
    建造者模式登机入口
    责任链模式登机入口
    享元模式登机入口
    组合模式登机入口
    门面模式登机入口
    桥接模式登机入口
    中介者模式登机入口
    迭代器模式登机入口
    状态模式登机入口
    解释器模式登机入口
    备忘录模式登机入口
    命令模式登机入口
    访问者模式登机入口
    软件设计7大原则和设计模式总结登机入口

    前言

    解释器模式从字面上来理解就是需要去解释某些内容的含义,而实际上这也正是解释器模式的作用。本文主要会介绍解释器模式的原理,并会结合一个简单的示例来加深我们对解释器模式的理解,解释器模式在我们的应用开发层已经有了很多轮子,所以我们也比较少再去重造轮子。

    什么是解释器模式

    解释器模式(Interpreter Pattern)是指给定一门语言,定义它的文法的一种表示(如:加减乘除表达式和正则表达式等),然后再定义一个解释器,该解释器用来解释我们的文法表示(表达式)。

    解释器模式是一种按照规定的语法(文法)来进行解析的一种设计模式,属于行为型模式。

    好了,装逼时刻又到了:Talk is cheap,Show you the code,先看一个非常简单的例子。

    终结符表达式和非终结符表达式

    在解释器模式中有终结符表达式和非终结符表达式这两个概念。

    • 终结符表达式(Terminal Expression):实现文法中与终结符有关的解释操作。文法中每一个终结符都有一个具体的终结符表达式与之相对应。比如我们的R=M+N运算,M和N就是终结符,对应的解析M和N的解释器就是终结符表达式。
    • 非终符结表达式(Nonterminal Expression):实现文法中与非终结符有关的解释操作。文法中的每一条规则都对应了一个非终结符表达式。非终结表达式一般是文法中的运算符或者关键字,如上面公示:R=M+N中的“+”号就是非终结符,解析“+”号的解释器就是一个非终结符表达式。

    解释器模式示例

    下面我们就以简单的加减法表达式类简单写一个示例:
    1、首先建立一个顶层的表达式接口:

    package com.zwx.design.pattern.interpreter;
    
    public interface IExpression {
        int interpret();
    }
    

    2、定义一个抽象的非终结表达式(比如加号和减号这种就属于非终结表达式):

    package com.zwx.design.pattern.interpreter;
    
    /**
     * 非终结表达式-抽象表达式
     */
    public abstract class AbstractNonTerminalExpression implements IExpression{
        protected IExpression leftExpression;
        protected IExpression rightExpression;
    
        public AbstractNonTerminalExpression(IExpression leftExpression, IExpression rightExpression) {
            this.leftExpression = leftExpression;
            this.rightExpression = rightExpression;
        }
    }
    

    3、因为本次示例中只列举加法和减法,所以我们还需要一个加法类和一个减法类:

    package com.zwx.design.pattern.interpreter;
    
    /**
     * 非终结表达式-具体表达式-加法表达式
     */
    public class AddExpression extends AbstractNonTerminalExpression {
        public AddExpression(IExpression leftExpression, IExpression rightExpression) {
            super(leftExpression, rightExpression);
        }
    
        @Override
        public int interpret() {
            return this.leftExpression.interpret() + this.rightExpression.interpret();
        }
    }
    
    package com.zwx.design.pattern.interpreter;
    
    /**
     * 非终结表达式-具体表达式-减法表达式
     */
    public class SubExpression extends AbstractNonTerminalExpression {
    
        public SubExpression(IExpression leftExpression, IExpression rightExpression) {
            super(leftExpression, rightExpression);
        }
    
        @Override
        public int interpret() {
            return this.leftExpression.interpret() - this.rightExpression.interpret();
        }
    }
    

    4、再建立一个终结表达式(如加减法运算中的数值):

    package com.zwx.design.pattern.interpreter;
    
    /**
     * 终结表达式-数值表达式
     */
    public class NumberExpression implements IExpression{
        private int value;
    
        public NumberExpression(String value) {
            this.value = Integer.valueOf(value);
        }
    
        @Override
        public int interpret() {
            return this.value;
        }
    }
    

    5、最后我们还需要一个上下文信息来存储我们的运算结果:

    package com.zwx.design.pattern.interpreter;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Stack;
    
    public class ExpressionContext {
        private Integer currValue;//记录当前运算结果,空表示暂未运算
        private Stack<IExpression> stack = new Stack<>();
    
        public ExpressionContext(String expression) {
            this.parse(expression);
        }
    
        private void parse(String expression) {
            String[] elementArr = expression.split(" ");
            for (int i=0;i<elementArr.length;i++){
                String element = elementArr[i];
                if (element.equals("+")){
                    IExpression leftExpression = stack.pop();//栈内元素出栈
                    IExpression rightExpression = new NumberExpression(elementArr[++i]);//取出+号后的下一个元素
                    IExpression addExpression = new AddExpression(leftExpression,rightExpression);
                    stack.push(new NumberExpression(addExpression.interpret() + ""));//将计算结果入栈
                }else if (element.equals("-")){
                    IExpression leftExpression = stack.pop();//栈内元素出栈
                    IExpression rightExpression = new NumberExpression(elementArr[++i]);//取出-号后的下一个元素
                    IExpression subExpression = new SubExpression(leftExpression,rightExpression);
                    stack.push(new NumberExpression(subExpression.interpret() + ""));//将计算结果入栈
                }else{
                    stack.push(new NumberExpression(element));//如果是数字则直接入栈
                }
            }
        }
    
        public int calcuate(){
            return stack.pop().interpret();//经过前面解析,到这里stack内只会剩下唯一一个数字,即运算结果
        }
    }
    

    6、最后新建一个测试类来测试一下:

    package com.zwx.design.pattern.interpreter;
    
    public class TestInterpreter {
        public static void main(String[] args) {
            ExpressionContext context = new ExpressionContext("666 + 888 - 777");
            System.out.println(context.calcuate());
            context = new ExpressionContext("123 - 456 + 11");
            System.out.println(context.calcuate());
    
        }
    }
    

    运行结果为:

    777
    -322
    

    解释器模式角色

    从上面示例中,我们可以得出解释器模式主要有4个角色:

    • 抽象表达式(Expression):一般会定义一个解释方法,具体如何解析会交由子类进行实现(如示例中的IExpression)。
    • 终结符表达式(Terminal Expression):实现文法中与终结符有关的解释操作(如示例中的AddExpression,SubExpression)。
    • 非终符结表达式(Nonterminal Expression):实现文法中与非终结符有关的解释操作(如示例中的NumberExpression)。
    • 上下文环境(Context):包含解释器之外的全局信息。一般用来存放文法中各个终结符所对应的具体值。

    解释器模式在JDK和Spring源码中应用

    这个在源码中的应用大家也应该可以猜测的出来了,比如说JDK中的正则表达式:Pattern类。还有Spring里面的ExpressionParse接口,Spring的这个表达式不知道大家有没有用过,这里面其实也是可以进行加减乘除运算的。如下就是一个简单的应用示例:
    在这里插入图片描述
    所以我们一开始就提到了,像这种解释器模式我们一般在业务开发中用的还是相对较少的,常用的表达式都有人已经帮我们解析好了,直接用就可以了,除非我们从事底层开发自己需要去定义较为复杂的表达式。

    解释器模式应用场景

    解释器模式主要可以运用在如下场景:

    • 1、当我们有一些需要重复解析的问题可以考虑定义一个表达式来进行表达。
    • 2、一些简单的语法如果需要解释的话也可以考虑解释器模式。

    解释器模式优缺点

    优点:

    • 1、扩展性比较强。从我们上面的示例中可以看出来了,我们每一个表达式都是一个类,所以如果需要修改某一个规则只需要修改对应的表达式类就可以了,扩展的时候新增一个新类就可以了。

    缺点

    • 1、当文法规则比较复杂时,会引起类膨胀,比较难维护。
    • 2、当文法规则比较复杂时,如果出错了,调试比较困难。
    • 3、执行效率比较低下。因为当表达式比较复杂,结果层层依赖的话会采用递归方式进行解析。

    总结

    本文主要介绍了解释器模式的基本使用,并通过一个简单的示例来帮助更好的理解解释器模式,当然这个示例写的比较简单,很多业务逻辑是没有考虑的,但是这些并不是本文的重点,本文的重点是介绍解释器模式的思想。最后我们还介绍了解释器模式模式在相关JDK源码中的体现,希望通过本文,大家可以更深刻的理解解释器模式的设计思想。

    请关注我,和孤狼一起学习进步

    展开全文
  • 设计模式-解释器模式(讲解及其实现代码)
  • 主要介绍了Java设计模式编程之解释器模式的讲解,解释器设计模式要注意其引发的性能问题,需要的朋友可以参考下
  • 主要为大家详细介绍了23种设计模式之java解释器模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 大话设计模式——解释器模式

    千次阅读 2022-03-13 22:05:22
    ①、什么是解释器模式 给定一个语言,定义它得到文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。 ②、主要解决什么问题 对于一些固定的文法构建一个解释句子的解释器 ③、如何解决 ...

    一、定义

    ①、什么是解释器模式

    给定一个语言,定义它得到文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

    ②、主要解决什么问题

    对于一些固定的文法构建一个解释句子的解释器

    ③、如何解决

    构建语法树,定义终极符与非终结符

    ④、什么时候使用

    如果一种特定类型的问题发生的频率足够高,那么可能就值得该问题的各个实例表述为一个简单语言的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题

    ⑤、使用场景

    1. 可以将一个需要解释执行的语言中的句子表示为一个抽象的语法树
    2. 一些重复出现的问题可以用一种简单的语言来进行表达
    3. 一个简单语法需要解释的场景

    ⑥、优缺点

    优点

    1. 可扩展性比较好,灵活。
    2. 增加了新的解释表达式的方法
    3. 易于实现简单文法
      缺点
    4. 可利用场景比较少
    5. 对于复杂的文法比较难以维护
    6. 解释器模式会引起类膨胀
    7. 解释器模式采用递归调用方法

    二、图

    概念图
    在这里插入图片描述

    拓展图
    在这里插入图片描述

    示例图:上海滩演奏
    在这里插入图片描述

    三、代码
    ①、代码类图
    在这里插入图片描述

    客户端
    static void Main(string[] args)
            {
                PlayContext context = new PlayContext();//实例化一个演奏内容
                //音乐-上海滩
                Console.WriteLine("上海滩:");          //控制台上显示内容
                context.PlayText ="O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ";               //设置文本内容
    
                Expression expression = null;
                try
                {
                    while (context.PlayText.Length>0)   //演奏内容是否大于零
                    {
                        string str = context.PlayText.Substring(0, 1);//str=截取索引为0的字符串
                        switch (str )                                 //判断str内容
                        {
                            case "O":                                   //str=O
                                expression = new Scale();               //实例化音阶类
                                break;
                            
                            case "C":
                            case "D":
                            case "E":
                            case "F":
                            case "G":
                            case "A":
                            case "B":
                            case "P":
                                expression = new Note();            //实例化音符类
                                break;
                            
                        }
                        expression.Interpret(context);              //执行解释器interpret方法
                    }
                }
                catch (Exception ex)
                {
    
                    Console.WriteLine(ex.Message);                  //显示错误信息
                }
                Console.Read();
            }
    

    演奏内容类

    //演奏内容
        class PlayContext
        {
            //演奏文本
            private string text;
            public string PlayText
            {
                get { return text; }
                set { text = value; }
            }
        }
    

    表达式类

    //表达式类
        abstract class Expression
        {
            //解释器
            public void Interpret(PlayContext context)
            {
                if (context.PlayText.Length == 0)           //判断文本长度时候为零
                {
                    return;                                 //返回
                }
                else
                {
                    string playKey = context.PlayText.Substring(0, 1);               //对playKey进行赋值,截取索引为0-1之前字符串
                    context.PlayText = context.PlayText.Substring(2);                //去除前两个字符串
                    double playValue = Convert.ToDouble(context.PlayText.Substring(0, context.PlayText.IndexOf(" ")));                               //对playText进行赋值,截取0到第一个空格之前
                    context.PlayText = context.PlayText.Substring(context.PlayText.IndexOf(" ") + 1);//去除第一个空格到索引为一的字符串
    
    
                    Excute(playKey, playValue);                                         //执行Excute方法
                }
    
    
               
            }
    

    音符类
    //音符类

     class Note:Expression
        {
            public override void Excute(string key, double value)//重写父类Expression的Excute方法
            {   
                string note = "";                                   
                switch (key )                                       //判断key内容
                {
                    case "C":
                        note = "1";//表示如果获得的key是C则演奏1(do),如果是D则演奏2(Re)
                        break;
                    case "D":
                        note = "2";
                        break;
                    case "E":
                        note = "3";
                        break;
                    case "F":
                        note = "4";
                        break;
                    case "G":
                        note = "5";
                        break;
                    case "A":
                        note = "6";
                        break;
                    case "B":
                        note = "7";
                        break;
    
    
                }
                Console.Write("{0}", note);                         //控制台上显示
            }
        }
    

    音阶类

    //音阶类
        class Scale :Expression
        {
            public override void Excute(string key, double value)       //重写父类Expression的Excute方法
            {
                string scale = "";
                switch (Convert.ToInt32(value ))                       //把value值转换为整数
                {
                    case 1:
                        scale = "低音";//如果获得的key是O并且value是1则演奏低音,2则中音,3则高音
                        break;
                    case 2:
                        scale = "中音";
                        break;
                    case 3:
                        scale = "高音";
                        break;
    
                }
    
                Console.Write("{0}", scale);                                //控制台上显示
            }
        }
    

    四、知识点
    相关知识点
    ①、try catch方法
    ②、switch case
    ③、substring(a,b)、substring(a)
    ④、IndexOf()查找字符串首次出现的位置

    涉及知识点

    1. 抽象类
      abstract关键字
      可以考虑把没有实际意义的父类和没有实际意义的方法体改为抽象类抽象方法
      抽象方法没有方法体
      抽象类不能实例化
      抽象方法必须被子类重写

    参考博文

    展开全文
  • 解释器模式代码示例

    2013-10-27 21:36:54
    解释器模式的示例代码和文档,学习解释器模式的参考资料。
  • 解释器模式这个模式和前面的访问者模式比较像,当然,我说的比较像是难的比较像,以及使用率是真的比较低,基本上没有使用的场景,访问者模式还有点使用场景,解释器模式,我们又不写解释器,这玩意 JVM 都帮我们...
  • 27解释器模式.zip

    2021-12-04 14:18:19
    27解释器模式.zip
  • Java设计模式-解释器模式

    千次阅读 2019-03-28 09:01:26
    解释器模式
  • JAVA解释器模式

    千次阅读 2018-09-16 23:19:01
    JAVA解释器模式 通过本文将学习到 1、前言 2、解释器模式的概念 3、解释器的UML图及角色结构 4、解释器模式的实现 5、解释器模式的优缺点及使用场景 6、总结 1、前言 上一场我聊过了命令模式,只是浅显的过...
  • 设计模式-解释器模式

    2016-11-16 23:13:26
    ios平台下讲解解释器模式简单代码,可也查看博客对设计模式的简单介绍或者定义http://blog.sina.com.cn/s/blog_161d504630102wxis.html
  • 解释器模式(Interpreter) 用意:定义一种语言,定义它的方法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
  • java利用解释器模式实现简单计算

    千次阅读 2019-04-01 11:52:57
    一个利用解释器模式进行的简单计算,只支持+,-,*,/,() 地址:https://gitee.com/hellobb/tools/tree/master/computing
  • 一、定义 1、定义         Given a language,define a representation for its grammar along with an interpreter that uses the ...该解释器使用该解释来解释语言中的句子
  • 解释器模式-Interpreter Pattern

    千次阅读 2019-07-04 16:27:34
    解释器模式是一种使用频率相对较低但学习难度较大的设计模式,它用于描述如何使用面向 对象语言构成一个简单的语言解释器。在某些情况下,为了更好地描述某一些特定类型的问 题,我们可以创建一种新的语言,这种语言...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 569,126
精华内容 227,650
关键字:

解释器模式