解释器模式-自定义语言的实现

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量517 收藏
点赞数
分类专栏： 设计模式的艺术 文章标签： java 算法 开发语言 解释器模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25308331/article/details/132109319
版权

 有时，我们希望输入一串字符串，然后计算机能够按照预先定义的文法规则来对这个字符串进行解释，从而实现相应的功能。

例如，我们想实现简单的加减法接收器，只需输入一个表达式，它就能计算出表达式结果。比如输入字符串：“2+4-1+4-5”,计算机输出4。像这种用户自己定义一套文法规则来实现对这些语句的解释，即设计一个自定义语言。此时可以使用解释器模式来实现自定义语言。

1 解释器模式

1.1 文法规则

在前面所提到的加法/减法解释器中，emigrants表达式都包含了3个语言单位，可以使用如下语法规则来定义：

expression ::= value | operation

operation ::= expression ‘+’ expression | expression ‘-’ expression

value ::= an integer // 一个整数值

::=

表示定义为

|

表示或

“{” 和 “}”

表示组合

*

表示出现0次或多次

语言单位

又称为语言构造成分，每一条语句所定义的字符串，如上例中的value和operation。

终结表达式

组成元素是最基本的语言单位，不能再进行分解。

非终结表达式

组成元素仍然可以是表达式，可以进一步分解。如expression 和 operation。

图 文法规则说明

​​​​​​​1.2 抽象语法树

除了使用文法规则来定义一个语言外，还可以通过一种被称为抽象语法树(Abstract Syntax Tree, AST)的图形方式来直观的表示语言的构成。每一棵抽象语法树对应一个语言实例。“2+4-1+4-5” 的抽象语法树表示为：

图 抽象语法树示意图

图中终结符表达式作为树的叶子节点，而非终结表达式作为非叶子节点，它们可将终结符表达式以及包含终结符和非终结符的子表达式作为其子节点。通过对抽象语法树的分析，可以识别出语言中的终结符类和非终结符类。

1.3 解释器模式概述

用于描述如何使用对象语言构成一个简单的语言解释器。定义一个语言的文法，并建立一个解释器来解释语言中的句子。这里的“语言”是指使用规定格式和语法的代码。

图 解释器模式结构图

  1. AbstractExpression，抽象表达式，声明了抽象的解释操作，是所有终结符表达式和非终结符表达式的父类。
  2. TerminalExpression，终结符表达式，实现了与文法中的终结符相关联的解释操作，在句子中的每个终结符都是该类的一个实例，它们的实例可以通过非终结符表达式组成较为复杂的句子。
  3. NonterminalExpression，非终结符表达式，实现了文法中非终结符的解释操作。在非终结符表达式中可以包含终结符表达式，也可以包含非终结符表达式，因此其解释操作一般通过递归的方式来实现。
  4. Context，环境类，又称为上下文，用于存储解释器之外的一些全局信息。通常存储了需要解释的语句。

1.3.1 解释器模式实现简单的英文控制指令

需求描述：每个指令对应一个表达式，该表达式可以是简单表达式，也可以是复合表达式。两个表达式之间可以通过and连接，形成复合表达式。简单表达式组成如下表：

移动方向(direction)

上（up）、下（down）、左（left）、右（right）

移动方式(action)

移动（move）、快速移动（run）

移动距离(distance)

为一个正整数

表 简单表达式的组成

例如“up move 5”表示向上移动5个单位。“dow run 10 and left move 20”表示向下快速移动10个单位然后向左移动20个单位。

direction ::= ‘up’|’down’|’left’|’right’;

action :: = ‘move’|’run’;

distance ::= an integer; //一个正整数

expression ::= direction action distance | complexExpression

complexExpression ::= expression ‘and’ expression

// 简单的英语控制指令，例如 left move 10
public interface AbstractExpression {

    void interpret();

}

public class ActionExpression implements AbstractExpression{

    private final String action;

    public ActionExpression(String action) {
        this.action = action;
    }

    @Override
    public void interpret() {
        if (action == null) {
            throw new RuntimeException("解析失败：行为值为空");
        }
        String tempStr = action.toLowerCase();
        switch (tempStr) {
            case "move":
                System.out.print("移动");
                break;
            case "run":
                System.out.print("快速移动");
                break;
            default:
                throw new RuntimeException("解析失败：行为值不合法");
        }
    }

}

public class ComplexExpression implements AbstractExpression{

    private AbstractExpression leftExpress;
    private AbstractExpression rightExpress;

    public ComplexExpression(AbstractExpression leftExpress, AbstractExpression rightExpress) {
        this.leftExpress = leftExpress;
        this.rightExpress = rightExpress;
    }

    @Override
    public void interpret() {
        leftExpress.interpret();
        System.out.print(" 然后 ");
        rightExpress.interpret();
    }

}

public class DirectionExpression implements AbstractExpression{

    private final String direction;

    public DirectionExpression(String direction) {
        this.direction = direction;
    }

    @Override
    public void interpret() {
        if (direction == null) {
            throw new RuntimeException("解析失败：方向值为空");
        }
        String tempStr = direction.toLowerCase();
        switch (tempStr) {
            case "up":
                System.out.print("向上");
                break;
            case "down":
                System.out.print("向下");
                break;
            case "left":
                System.out.print("向左");
                break;
            case "right":
                System.out.print("向右");
                break;
            default: throw new RuntimeException("解析失败：方向值不合法");
        }
    }

}

public class DistanceExpression implements AbstractExpression{

    private final String value;

    public DistanceExpression(String value) {
        this.value = value;
    }

    @Override
    public void interpret() {
        if (value == null) {
            throw new RuntimeException("解析失败：距离为空");
        }
        System.out.print(Integer.valueOf(value) + "个单位");
    }

}

public class SimpleExpression implements AbstractExpression{

    private final AbstractExpression direction;
    private final AbstractExpression action;
    private final AbstractExpression distance;

    public SimpleExpression(AbstractExpression direction, AbstractExpression action, AbstractExpression distance) {
        this.direction = direction;
        this.action = action;
        this.distance = distance;
    }

    @Override
    public void interpret() {
        direction.interpret();
        action.interpret();
        distance.interpret();
    }

}

public class Client {

    private static final String[] expressArr = {"left move 12 and down run 5","down run 3","right run 1 and left move 12 and left run 4 and down move 12"};


    public static void main(String[] args) {
        for (String str : expressArr) {
            String[] strArr = str.split(" ");
            Stack<AbstractExpression> expressionStack = new Stack<>();
            for (int i = 0; i < strArr.length; i++) {
                if ("and".equals(strArr[i])) {
                    AbstractExpression leftExp = expressionStack.pop();
                    AbstractExpression rightExp = buildSimpleExp(strArr, i + 1);
                    expressionStack.push(new ComplexExpression(leftExp,rightExp));
                    i += 3;
                } else {
                    expressionStack.push(buildSimpleExp(strArr,i));
                    i += 2;
                }
            }
            expressionStack.pop().interpret();
            System.out.println();
        }
//        运行结果：
//        向左移动12个单位 然后 向下快速移动5个单位
//        向下快速移动3个单位
//        向右快速移动1个单位 然后 向左移动12个单位 然后 向左快速移动4个单位 然后 向下移动12个单位
    }

    private static AbstractExpression buildSimpleExp(String[] strArr, int start) {
        AbstractExpression directionExp = new DirectionExpression(strArr[start]);
        AbstractExpression actionExp = new ActionExpression(strArr[start + 1]);
        AbstractExpression distance = new DistanceExpression(strArr[start + 2]);
        return new SimpleExpression(directionExp,actionExp,distance);
    }

}

1.3.2 “简单的英语控制指令” 为啥要用解释器模式?

 其实，上面这个需求在不用解释器模式的情况下也可以实现，而且只需在一个类就能完成。

public class Client2 {

    private static final String[] expressArr = {"left move 12 and down run 5","down run 3","right run 1 and left move 12 and left run 4 and down move 12"};

    public static void main(String[] args) {
        System.out.println("不用解释器模式实现需求：");
        System.out.println("--------------");
        for (String str : expressArr) {
            StringBuilder sb = new StringBuilder();
            String[] strArr = str.split(" ");
            for (String s : strArr) {
                switch (s) {
                    case "and":
                        sb.append(" 然后 ");
                        break;
                    case "up":
                        sb.append("向上");
                        break;
                    case "down":
                        sb.append("向下");
                        break;
                    case "left":
                        sb.append("向左");
                        break;
                    case "right":
                        sb.append("向右");
                        break;
                    case "move":
                        sb.append("移动");
                        break;
                    case "run":
                        sb.append("快速移动");
                        break;
                    default:
                        sb.append(s).append("个单位");
                }
            }
            System.out.println(sb);
        }
//        运行结果：
//        不用解释器模式实现需求：
//        --------------
//        向左移动12个单位 然后 向下快速移动5个单位
//        向下快速移动3个单位
//        向右快速移动1个单位 然后 向左移动12个单位 然后 向左快速移动4个单位 然后 向下移动12个单位
    }
    
}

不用解释器模式实现的代码量更少、类的数量也更少而且运行速度也更快。所以为什么要用解释器模式呢？

  1. 文法规则让需求更加清晰。上面分析的5个表达式完整的表示了这个需求，通过拆解表达式的形式，由复合语句到不可拆分表达式。
  2. 扩展及修改方便。不用解释器的情况下条件判断语句太多了，如果修改或者增加某个含义，则在修改代码时将会遇到很大的困难。而解释器模式把各种语句以类的形式来表示，只需要修改相应类即可。

1.3.3 Context的作用

上下文Context 类用于存储解释器之外的一些全局信息。通常作为参数被传递到所有表达式的解释方法interpret()中，可以在Context对象中存储和访问表达式解释器的状态，向表达式解释器提供一些全局的、公共的数据。此外，还可以在Context中增加一些所有表达式解释器都共有的功能，减轻解释器的职责。

需求描述：实现一套简单的基于字符串界面的格式化指令，可以根据输入的指令在字符串界面中输出一些格式化内容。

例如：”LOOP 2 PRINT 今天发工资啦 SPACE SPACE PRINT 亲爱的老婆  BREAK END PRINT 走 SPACE SPACE PRINT 下馆子去！” 将输出如下结果：

今天发工资啦  亲爱的老婆

今天发工资啦  亲爱的老婆

走  下馆子去！

BREAK

换行

SPACE

空格

END

循环结束

PRINT

打印，后面字符串表示打印的内容

LOOP

循环，后面的数字表示循环次数

 　表 关键字表示含义

每个关键字对应一条命令，程序根据关键字执行相应的处理操作。

primitive ::= ‘PRINT string’ | ‘BREAK’ | ‘SPACE’; // 基本命令，string 为字符串

command ::= loop | primitive; // 语句命令

expression ::= command *; //  表达式，一个表达式包含多条命令

loop ::= LOOP number expression ‘END’; // j循环命令，number 为自然数

public class Context {

    private final String[] commandStrArr;
    private int currentPos = 0;

    public Context(String str) {
        commandStrArr = str.split(" ");
    }

    public String getCurrentCommand() {
        return commandStrArr[currentPos];
    }

    public void skip() { ++currentPos;}

    public void interpreter(List<AbstractCommand> commandList) {
        while (true) {
            if (currentPos >= commandStrArr.length) {
                break;
            }
            if ("END".equals(commandStrArr[currentPos])) {
                skip();
                break;
            }
            AbstractCommand command = new ConcreteCommand();
            command.interpreter(this);
            commandList.add(command);
        }
    }

}

public interface AbstractCommand {

    void interpreter(Context context);

    void execute();

}

public class ConcreteCommand implements AbstractCommand{

    private AbstractCommand command;

    @Override
    public void interpreter(Context context) {
        if ("LOOP".equals(context.getCurrentCommand())) {
            command = new LoopCommand();
        } else {
            command = new PrimitiveCommand();
        }
        command.interpreter(context);
    }

    @Override
    public void execute() {
        command.execute();
    }
}

public class ExpressionCommand implements AbstractCommand{

    private final List<AbstractCommand> commandList = new ArrayList<>();

    @Override
    public void interpreter(Context context) {
        context.interpreter(commandList);
    }

    @Override
    public void execute() {
        for (AbstractCommand command : commandList)
            command.execute();
    }

}

public class LoopCommand implements AbstractCommand{

    private Integer number;
    private AbstractCommand command;

    @Override
    public void interpreter(Context context) {
        context.skip();
        String value = context.getCurrentCommand();
        context.skip();
        number = Integer.valueOf(value);
        command = new ExpressionCommand();
        command.interpreter(context);
    }

    @Override
    public void execute() {
        for (int i = 0; i < number; i++) {
            command.execute();
        }
    }

}

public class PrimitiveCommand implements AbstractCommand {

    private String value;

    @Override
    public void interpreter(Context context) {
        switch (context.getCurrentCommand()) {
            case "PRINT":
                context.skip();
                value = context.getCurrentCommand();
                break;
            case "BREAK":
                value = "\n";
                break;
            case "SPACE":
                value = " ";
                break;
        }
        context.skip();
    }

    @Override
    public void execute() {
        System.out.print(value);
    }

}

public class Client {

    private final static String commandStr = "LOOP 2 LOOP 2 PRINT 今天发工资啦 SPACE SPACE PRINT 亲爱的老婆 BREAK END PRINT 走 SPACE SPACE PRINT 下馆子去 BREAK END";

    public static void main(String[] args) {
        Context context = new Context(commandStr);
        AbstractCommand command = new ExpressionCommand();
        command.interpreter(context);
        command.execute();
//        运行结果：
//        今天发工资啦  亲爱的老婆
//        今天发工资啦  亲爱的老婆
//        走  下馆子去
//        今天发工资啦  亲爱的老婆
//        今天发工资啦  亲爱的老婆
//        走  下馆子去
    }

}

在这里，Context的作用是存储一些公共变量及实现公有方法。

1.3.4 解释器模式实现简单加减法

需求描述：实现简单的加减法接收器，只需输入一个表达式，它就能计算出表达式结果。比如输入字符串：“2+4-1+4-5”,计算机输出4。

number ::= a integer;// 一个整数

operation ::= expression ‘+|-’ expression

expression ::= number | operation

public class Context {

    private final String[] expressionArr;
    private Integer currentPos = 0;

    public Context(String str) {
        expressionArr = str.split(" ");
    }

    public String getCurrentExp() {
        return getExp(0);
    }

    public String getNextExp() {
        return getExp(1);
    }

    public String getPreExp() {
        return getExp(-1);
    }

    private String getExp(int num) {
        return currentPos + num >= expressionArr.length || currentPos + num < 0 ? null : expressionArr[currentPos + num];
    }

    public void skip(int num) {
        currentPos += num;
    }

    public void interpreter(AbstractExpression preExpression) {

    }

}


public interface AbstractExpression {

    void interpreter(Context context);

    Integer execute();

}

public class ConcreteExpression implements AbstractExpression{

    private AbstractExpression expression;

    @Override
    public void interpreter(Context context) {
        if (context.getNextExp() != null) {
            expression = new OperationExpression();
        } else {
            expression = new NumberExpression();
        }
        expression.interpreter(context);
    }

    @Override
    public Integer execute() {
        return expression.execute();
    }

}

public class NumberExpression implements AbstractExpression{

    private Integer number;

    @Override
    public void interpreter(Context context) {
        number = Integer.valueOf(context.getCurrentExp());
        String type = context.getPreExp();
        if ("-".equals(type)) {
            number = -number;
        }
    }

    @Override
    public Integer execute() {
        return number;
    }
}

public class OperationExpression implements AbstractExpression{

    private AbstractExpression leftExpression;
    private AbstractExpression rightExpression;

    @Override
    public void interpreter(Context context) {
        leftExpression = new NumberExpression();
        leftExpression.interpreter(context);
        context.skip(2);
        rightExpression = new ConcreteExpression();
        rightExpression.interpreter(context);
    }

    @Override
    public Integer execute() {
        return leftExpression.execute() + rightExpression.execute();
    }

}

/* 实现简单的加减法接收器，只需输入一个表达式，
它就能计算出表达式结果。比如输入字符串：
“2 + 4 - 1 + 4 - 5”,计算机输出4。 */
public class Client {

    private static final String STR = "23 - 5 + 22 - 3 - 33 - 22 + 1";

    public static void main(String[] args) {
        Context context = new Context(STR);
        AbstractExpression expression = new ConcreteExpression();
        expression.interpreter(context);
        System.out.println(expression.execute());
//        运行结果：
//        17
    }

}

2 优缺点

优点：

  1. 易于改变和扩展文法，使用类来表示文法规则，因此可以通过继承等机制来改变或扩展文法。
  2. 实现文法较为容易。增加新的解释表达式较为方便，只需增加相关表达式类即可，原有表达式类无须修改，符合开闭原则。

缺点：

  1. 对于复杂文法难以维护。如果一种语言包含太多文法规则，类的数量将会急剧增加，导致系统难以管理和维护，可以考虑使用语法分析程序等方式来取代解释器模式。
  2. 执行效率较低，使用了大量循环和递归调用，而且代码调试过程也比较麻烦。

3 适用场景

  1. 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
  2. 执行效率不是关键，一个语言的文法较为简单。

黄名富
关注
专栏目录
zkk950815#design-pattern-java-1#自定义语言的实现——解释器模式（二）1
07-25
除了使用文法规则来定义一个语言，在解释器模式中还可以通过一种称之为抽象语法树(Abstract Syntax Tree, AST)的图形方式来直观地表示语言的构
自定义表达式解析器
weixin_34126557的博客
01-09 705
解析器： import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.List; import java.util.regex.Pattern; import javax.scrip...
c++解释器模式
waxtear的博客
02-21 558
本文主要运用解释器来解析数学表达式。其中还用到了生产者模式，代理模式，策略模式，状态模式，模板方法，单例模式。
行为型设计模式(十一) 之 自定义表达式和解析可用解释器模式
子云心的博客
11-09 529
1 定义 解释器模式（InterpreterPattern）属于行为型设计模式，它主要是为了解决当出现一种特定类型的问题且发生频率足够高时，那么就可以将该类问题的各个实现表述为一个简单的语言句子，然后通过构造一个解释器来解释这些句子来解决问题。这是一种使用了编译语言的思想来分析应用中的实例的行为。通俗些说就是提供一种有语法规则的表达式，然后再设计出一个解释器来解释该表达式的意思。例如现在我们需要实现一个非阿拉伯数字而是可以识别汉字的计算器程序，当传入如“伍加拾壹加捌减六”便可像传入“5+11+8-6”一.
算数表达式的计算——Expression 类与stack混合的实现
RainEagle专栏
06-28 674
//*************************************************************************************************************************//算数表达式计算//实现正整数的+-*/运算.//***************************************************
综合实例：用C语言实现一个自定义的shell程序
热门推荐
str999_cn的专栏
12-03 1万+
一个shell需要实现若干功能，首先对要实现的功能做一个简要介绍：       （1）输出重定向：就是把执行某命令后的结果输出到某个文件。例如： ls -al > list.txt       （2）输入重定向：这里的，而是从文件中取出数据到指定的文件中。例如： cat > newfile       上述命令将test3中的数据取出，然后输入到newfile这个文
72丨解释器模式：如何设计实现一个自定义接口告警规则功能？1
08-03
解释器模式是一种设计模式，用于创建能解析特定语言或规则集的解释器。这种模式的核心在于定义一个表达式的抽象语法树（AST），并提供一个解释器来遍历这棵树，执行与之相关的操作。在 GoF 的《设计模式》书中，解释...
设计模式-解释器模式
11-16
在iOS开发中，解释器模式的一个常见应用是实现自定义的脚本语言，允许用户以一种简单的方式与应用交互。例如，通过定义简单的指令集，用户可以控制动画、改变界面状态等。在给定的文件"设计模式-解释器"中，可能包含...
解析Java的设计模式编程之解释器模式的运用.docx
04-02
在Java中，解释器模式可以用于创建自定义的解析器，以处理特定的语法或逻辑。 **0. 模式定义** 解释器模式定义了一种文法表示，并提供了一个解释器来解释该文法中的句子。它通常涉及创建一个抽象语法树（AST），...
javascript设计模式 – 解释器模式原理与用法实例分析
10-15
解释器模式可以用于多种场景，例如，自定义的配置语言解释、数学表达式的解析、正则表达式匹配等。它的优势在于可以灵活地为特定的语言创建解释器，但是它也存在着代码复杂和性能问题，因此在选择使用解释器模式时，...
自定义语言的实现——解释器模式
tnt32的专栏
08-04 6183
有朋友一直在等待我的解释器模式文稿，，现把某个版本发在博客上，欢迎大家讨论！        虽然目前计算机编程语言有好几百种，但有时候我们还是希望能用一些简单的语言来实现一些特定的操作，我们只要向计算机输入一个句子或文件，它就能够按照预先定义的文法规则来对句子或文件进行解释，从而实现相应的功能。例如提供一个简单的加法/减法解释器，只要输入一个加法/减法表达式，它就能够计算出表达式结果，如图1
3个步骤实现简单语言解释器（自制简易编程语言）
weixin_34304013的博客
09-12 4537
本文讲的是3个步骤实现简单语言解释器（自制简易编程语言）， 前段时间，我用javascript重新编写了一个16位的虚拟机，用它实现了一个定制的CPU架构和汇编语言，汇编器和调试器。虽然从头编一个语言可以完全实现自己的自定义目标，但过程却及其复杂。为了使自己的编程过程更有效率，我决定使用Lel（布局表达式语言，Layout Expression Lan...
自定义语言的实现——解释器模式（一）
duoerbasilu
07-03 332
有朋友一直在等待我的解释器模式文稿，，现把某个版本发在博客上，欢迎大家讨论！ 虽然目前计算机编程语言有好几百种，但有时候我们还是希望能用一些简单的语言来实现一些特定的操作，我们只要向计算机输入一个句子或文件，它就能够按照预先定义的文法规则来对句子或文件进行解释，从而实现相应的功能。例如提供一个简单的加法/减法解释器，只要输入一个加法/减法表达式，它就能够计算出表达式结果，如图18-1所示，当...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 621
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1114
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 770
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 449
默认对常规Session的理解和使用，如何使用Set-Cookie。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1003
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 255
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Java解释器模式：定义与实现简单语言功能
总结来说，这篇教程通过实例演示了如何使用Java实现解释器模式来构建一个简单的语言解析器，这不仅有助于理解模式的工作原理，还能为开发者提供一种创建可扩展和自定义语言解析工具的基础框架。通过实践这个模式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值