JAVA设计模式之解释器模式

最新推荐文章于 2024-07-09 09:58:32 发布
最新推荐文章于 2024-07-09 09:58:32 发布
阅读量202 收藏
点赞数
分类专栏： JAVA设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwg1226/article/details/119761631
版权

一 概述

1.1 定义

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

  • 解释器模式属于行为型模式
  • 解释器模式提供了一种解释语言的语法或表达式的方式
  • 解释器模式实际开发中很少用到

1.2 UML 类图

在这里插入图片描述
角色说明：

  • AbstractExpression（抽象表达式）：定义一个抽象的解释方法，其具体的实现在各个具体的子类解释器中完成
  • TerminalExpression（终结符表达式）：实现对文法中与终结符有关的解释操作
  • NonterminalExpression（非终结符表达式）：实现对文法中的非终结符有关的解释操作
  • Context（环境角色）：包含解释器之外的全部信息
  • Client（客户端角色）：解析表达式，构建抽象语法树，执行具体的解释操作等

二 实现

以加减法的实现为例，我们实现下面表达式的解释并输出结果，为了方便解释，在表达式中介加了空格方便处理。

a = 1024
b = 512
a + b
a - b

2.1 创建抽象表达式

    public abstract class ArithmeticExpression {//抽象算术表达式

        public abstract Object interpret(Context context);//抽象解释方法
    }

2.2 终结符表达式

从上面的表达式可以看出，终结符有两种，一种是数字，另外一种是变量。

    //数字表达式，用来解释数字
    public class NumExpression extends ArithmeticExpression {
        private String strNum;

        public NumExpression(String strNum) {
            this.strNum = strNum;
        }

        @Override
        public Integer interpret(Context context) {//解释数字
            return Integer.parseInt(strNum);
        }
    }

    //变量表达式，用来解释变量
    class VarExpression extends ArithmeticExpression {
        private String var;

        public VarExpression(String var) {
            this.var = var;
        }

        @Override
        public String interpret(Context context) {//解释变量
            return var;
        }
    }

2.3 创建非终结符表达式

上面的表达式有三种非终结符，分别是 + 号、- 号和 = 号。

     //加法表达式，用来解释加法,如a+b
    public class AddExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//加号左右两边的内容

        public AddExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public Integer interpret(Context context) {//解释加法表达式的结果，即算出left+right的结果
            return  context.get((String) left.interpret(context)) + 
                context.get((String) right.interpret(context));
        }
    }

    //减法表达式，用来解释减法,如a-b
    public class SubExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//减号左右两边的内容

        public SubExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public Integer interpret(Context context) {//解释减法表达式的结果，即算出left-right的结果
            return context.get((String) left.interpret(context)) - 
                context.get((String) right.interpret(context));
        }
    }
    
    //等号表达式，用来解释变量赋值，如a=1024
    public class EqualExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//等号左右两边的内容

        public EqualExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }


        @Override
        public Object interpret(Context context) {
        //解释等号表达式的结果，并将结果保存到context，变量名为key,值为value
            context.put((String) left.interpret(context), (int) right.interpret(context));
            return null;
        }
    }

2.4 创建环境角色

创建环境主要包含解释器之外的全部信息，这里用来保存变量以及其值。

    public class Context {
        Map<String, Object> mMap = new HashMap<>();//使用HashMap来保存结果

        public void put(String key, int value) {
            mMap.put(key, value);
        }

        public int get(String key) {
            return (int) mMap.get(key);
        }
    }

2.5 创建客户端角色：

客户端角色主要负责解析表达式，构建抽象语法树，执行具体的解释操作等。

     public class Calculator {//计算器类
        Context mContext = new Context();
        private ArithmeticExpression mExpression;

        public void read(String expression) {//读取表达式
            String[] split = expression.split(" ");//表达式以空格隔开，方便拆分
            switch (split[1]) {//根据不同符号去执行具体的解析操作
                case "=":
                    new EqualExpression(new VarExpression(split[0]),
                    new NumExpression(split[2])).interpret(mContext);
                    break;
                case "+":
                    mExpression = new AddExpression(new VarExpression(split[0]), 
                    new VarExpression(split[2]));
                    break;
                case "-":
                    mExpression = new SubExpression(new VarExpression(split[0]),
                    new VarExpression(split[2]));
                    break;
            }

        }

        public int calculate() {//计算结果
            return (int) mExpression.interpret(mContext);
        }
    }

2.6 客户端测试

     public void test() {
        Calculator calculator = new Calculator();
        calculator.read("a = 1024");//读取表达式
        calculator.read("b = 512");
        System.out.println("a = 1024");
        System.out.println("b = 512");

        calculator.read("a + b");
        System.out.println("a + b = " + calculator.calculate());//计算结果
        calculator.read("a - b");
        System.out.println("a - b = " + calculator.calculate());
    }

输出结果：

a = 1024
b = 512
a + b = 1536
a - b = 512

三 总结

3.1 应用场景

  • 简单的语法需要解释时，如解释一个 sql 语句
  • 一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是 a+b-cd，有时是 ab+c-d 等，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式

3.2 优点

灵活的扩展性，想扩展语法规则时只需新增新的解释器就可以了。如上面的例子中，想增加乘除法，只想增加相应的解释类，并增加相应的表达式解释操作即可。

3.3 缺点

  • 每一个文法都至少对应一个解释器，会产生大量的类，难于维护
  • 解释器模式由于大量使用循环和递归，需要考虑效率的问题，而且调试也不方便
  • 对于复杂的文法，构建其抽象语法树会显得异常繁琐
  • 所以不推荐在重要的模块中使用解释器模式，维护困难

四 Android 中的源码实例分析

对于 AndroidManifest.xml 这个文件，我们是相当熟悉。实际上 AndroidManifest.xml 是由 PackageManagerService 使用了 PackageParser 这个类来解释的，这里面就用到了解释器模式。对于 AndroidManifest.xml 中的每一个标签，都有对应的类去保存相应的信息。

4.1 PackageParser 的 parseBaseApkCommon 方法

基于 Android 27 的源码，不同版本的源码方法名可能不一样。

    private Package parseBaseApkCommon(Package pkg, Set<String> acceptedTags, Resources res,
                                       XmlResourceParser parser, int flags, String[] outError) 
            throws XmlPullParserException, IOException {
        //其他代码略
        if (tagName.equals(TAG_APPLICATION)) {
            //其他代码略
            if (!parseBaseApplication(pkg, res, parser, flags, outError)) {//解释application标签
                return null;
            }
        } else if (tagName.equals(TAG_OVERLAY)) {
            //其他代码略
        } else if (tagName.equals(TAG_KEY_SETS)) {
            if (!parseKeySets(pkg, res, parser, outError)) {
                return null;
            }
        } else if (tagName.equals(TAG_PERMISSION_GROUP)) {
            if (!parsePermissionGroup(pkg, flags, res, parser, outError)) {
                return null;
            }
        } else if (tagName.equals(TAG_PERMISSION)) {
            if (!parsePermission(pkg, res, parser, outError)) {
                return null;
            }
        } else if (tagName.equals(TAG_PERMISSION_TREE)) {
            if (!parsePermissionTree(pkg, res, parser, outError)) {
                return null;
            }
        } else if (tagName.equals(TAG_USES_PERMISSION)) {
            if (!parseUsesPermission(pkg, res, parser)) {
                return null;
            }
        } else if (tagName.equals(TAG_USES_PERMISSION_SDK_M)
                || tagName.equals(TAG_USES_PERMISSION_SDK_23)) {
            if (!parseUsesPermission(pkg, res, parser)) {
                return null;
            }
        } else if (tagName.equals(TAG_USES_CONFIGURATION)) {
            //其他代码略
        } else if (tagName.equals(TAG_USES_FEATURE)) {
            //其他代码略
        } else if (tagName.equals(TAG_FEATURE_GROUP)) {
            //其他代码略
        } else if (tagName.equals(TAG_USES_SDK)) {
            //其他代码略
        } else if (tagName.equals(TAG_SUPPORT_SCREENS)) {
            //其他代码略
        } else if (tagName.equals(TAG_PROTECTED_BROADCAST)) {
            //其他代码略
        } else if (tagName.equals(TAG_INSTRUMENTATION)) {
            //其他代码略
        } else if (tagName.equals(TAG_ORIGINAL_PACKAGE)) {
            //其他代码略
        } else if (tagName.equals(TAG_ADOPT_PERMISSIONS)) {
            //其他代码略
        } else if (tagName.equals(TAG_USES_GL_TEXTURE)) {
            //其他代码略
        } else if (tagName.equals(TAG_COMPATIBLE_SCREENS)) {
            //其他代码略
        } else if (tagName.equals(TAG_SUPPORTS_INPUT)) {//
            //其他代码略
        } else if (tagName.equals(TAG_EAT_COMMENT)) {
            //其他代码略
        } else if (tagName.equals(TAG_PACKAGE)) {
            //其他代码略
        } else if (tagName.equals(TAG_RESTRICT_UPDATE)) {
            //其他代码略
        } else if (RIGID_PARSER) {
            //其他代码略
        } else {
            //其他代码略
        }
    }

从上面代码可以看到，就是对各个标签的内容进行解释。我们再来看看 parseBaseApplication 这个方法，这个是对 Application 进行解释。

4.2 parseBaseApplication 方法

    private boolean parseBaseApplication(Package owner, Resources res,
                                         XmlResourceParser parser, int flags, String[] outError)
            throws XmlPullParserException, IOException {

        //其他代码略
        String tagName = parser.getName();
        if (tagName.equals("activity")) {//解释activity
            Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs, false,
                    owner.baseHardwareAccelerated);
            //其他代码略

        } else if (tagName.equals("receiver")) {//解释receiver
            Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs,
                    true, false);
            //其他代码略

        } else if (tagName.equals("service")) {//解释service
            Service s = parseService(owner, res, parser, flags, outError, cachedArgs);
            //其他代码略

        } else if (tagName.equals("provider")) {//解释provider
            Provider p = parseProvider(owner, res, parser, flags, outError, cachedArgs);
            //其他代码略

        } else if (tagName.equals("activity-alias")) {
            Activity a = parseActivityAlias(owner, res, parser, flags, outError, cachedArgs);
            //其他代码略

        } else if (parser.getName().equals("meta-data")) {
            //其他代码略
        } else if (tagName.equals("static-library")) {
            //其他代码略
        } else if (tagName.equals("library")) {
            //其他代码略

        } else if (tagName.equals("uses-static-library")) {
            if (!parseUsesStaticLibrary(owner, res, parser, outError)) {
                return false;
            }

        } else if (tagName.equals("uses-library")) {
            //其他代码略

        } else if (tagName.equals("uses-package")) {
            //其他代码略
        } else {
            //其他代码略
        }
        //其他代码略

        return true;
    }

可以看到，上面有对 activity、receiver、service 等标签的解释，activity 的具体解释在 parseActivity 这个方法里面，有兴趣的可以自行去看下，这里就不细说了，同时可以看到 receiver 也是在 parseActivity 这个方法中解释。

Big Skipper
关注
专栏目录
设计模式之解释器模式-不解释，自己看！
ISmileLi的博客
03-08 294
一、解释器模式的概念 解释器模式属于行为型模式，它提供一个文法表达式处理接口，该接口解释一个特定的上下文，它用编译语言的方式来分析应用中的实例对象。 二、解释器模式使用场景 1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。 三、解释器模式构建方法 1、环境类（Context） 环境类又称为上下文...
Java设计模式之解释器模式_动力节点Java学院整理
08-29
Java 设计模式之解释器模式 解释器模式是一个行为类模式，它定义了一个语言的文法表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。该模式的结构主要包括抽象解释器、终结符表达式、非终结符...
深入浅出解释器模式
专注JAVA开发
10-19 764
一、引子 其实没有什么好的例子引入解释器模式，因为它描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发编译器中；在实际应用中，我们可能很少碰到去构造一个语言的文法的情况。        虽然你几乎用不到这个模式，但是看一看还是能受到一定的启发的。   二、定义与结构 解释器模式的定义如下：定义语言的文法，并且建立一个解释器来解释该语言中的句子。它属于类的行为模式。这里的语
Java【解释器模式】原理详解
kiingking的博客
07-09 455
解释器模式（Interpreter Pattern）是一种行为型设计模式，它允许你定义语言的文法，并且构建一个解释器来解释该语言中的句子。这个模式特别适用于当一个特定领域的问题可以用一种简单的语言来描述和解决时。解释器模式的核心在于构建一个抽象语法树（Abstract Syntax Tree, AST），并遍历这棵树来解释语言中的句子。解释器模式最适合于文法简单且不会频繁变化的场景，以及当性能不是主要关注点的情况下。对于复杂的语言解析，通常使用更专业的工具如ANTLR或Yacc。
JAVA解释器模式
帅哥威的博客
09-16 2426
JAVA解释器模式 通过本文将学习到 1、前言 2、解释器模式的概念 3、解释器的UML图及角色结构 4、解释器模式的实现 5、解释器模式的优缺点及使用场景 6、总结 1、前言 上一场我聊过了命令模式，只是浅显的过了一遍。接下来要谈谈解释器模式了。 对了，突然想聊聊鲁迅先生，如果在整个学生时代要说我最喜欢的文学家的话，周树人先生当之无愧！他的语句犹如手术刀般的锋利，可以直刺心窝...
java设计模式之解释器模式
为者常成，行者常至
02-18 758
在编译原理中，一个算术表达式通过词法分析器形成词法单远，而这些词法单远再通过语法分析器构建语法分析树，最终形成一颗抽象的语法分析树，（词法分析器和语法分析器都可以看做是解释器）解释器模式是指给定一个语言（表达式），定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子（表达式）。
Java设计模式之解释器模式
Bulut0907
09-02 481
定义：解释器模式(Interpreter Pattern)，是指给定一个语言(表达式)，来表示它的文法，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)，并得到结果。例如在编译原理中，一个算术表达式通过词法分析器形成词法单元，而后这些词法单元再通过语法分析器构建成一颗抽象语法分析树。这里的词法分析器和语法分析器都可以看做是解释器优点易于扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来扩展文法每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
JAVA设计模式之解释器模式详解
09-03
解释器模式是一种设计模式，属于类行为模式，它允许我们为特定语言定义语法，并提供一个解释器来解析这种语言中的句子。在Java中，解释器模式通常用于处理简单的语言或表达式，例如布尔表达式计算。 在解释器模式中...
Java设计模式之解释器模式（Interpreter模式）介绍
09-03
解释器模式（Interpreter模式）是设计模式的一种，主要用于在程序设计中实现对特定语言或表达式的解释。在Java中，这种模式的应用可以帮助我们构建一种语言的解析器，从而理解和执行该语言的句子。以下是对解释器...
【Java设计模式】解释器模式
最新发布
09-03
该应用程序使用Java中的解释器模式来解析和评估算术表达式，如“5 + 3 * 2”。在这里，解释器将表达式的每个部分转换为表示数字和操作的对象。这些对象遵循定义的语法，使应用程序能够根据算术规则正确理解和计算...
java常用设计模式-解释器模式
08-28
解释器模式是一种行为设计模式，它定义了一种语言和该语言的解释器，使得可以使用该语言来表达一些特定的操作。该模式适用于需要解释一些特定语言的场景，例如编译器、表达式计算器等。 在 Java 中，可以使用抽象...
Java解释器模式
weixin_44256581的博客
08-21 192
一、四则运算问题 通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求： 先输入表达式的形式，比如 a+b+c-d+e, 要求表达式的字母不能重复。 在分别输入a ,b, c, d, e 的值。 最后求出结果：如图 传统方案解决四则运算问题分析 编写一个方法，接收表达式的形式，然后根据用户输入的数值进行解析，得到结果。 问题分析：如果加入新的运算符，比如 * / ( 等等，不利于扩展，另外让一个方法来解析会造成程序结构混乱，不够清晰。 解决方案：可以考虑使用解释器模式， 即： 表达式 -&g
20 迭代器模式
hughtw的专栏
03-11 516
20 迭代器模式 概念：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示 适用场景     一个聚集对象不管是什么都需要遍历的时候     或者对聚集有多种方式遍历时 作用     迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。
java 解释器模式_Java解释器模式
weixin_27024175的博客
02-18 195
解释器模式提供了一种评估计算语言语法或表达式的方法。 这种类型的模式属于行为模式。 这种模式涉及实现一个表达式接口，它告诉解释一个指定的上下文。 此模式用于SQL解析，符号处理引擎等。实现示例我们将创建一个接口Expression并且在具体的类实现这个Expression接口。 定义了一个TerminalExpression类，用作所讨论的上下文的主解释器。 其他的类 - OrExpression...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值