java设计模式-解释器模式

翻译模式:

给出一种语言，定义其语法表示形式，并定义一个解释器，使用该表示形式来解释该语言中的句子.

解释器模式可以解决-如果某种特定类型的问题足够频繁地发生解释器模式，则可能有必要用简单的语言将问题的每个实例描述为一个句子. 这样可以构建一个解释器，通过解释句子来解决问题.

终端表达式和非终端表达式可以理解如下: 在公式R = R1 + R2中，R1和R2是终端表达式，而+是非终端表达式（后跟终端符号）.

每个字符的代码----

AbstractExpression（抽象表达式），声明一个抽象解释操作解释器模式，此接口由抽象语法树中的所有节点（即终端表达式和非终端表达式）共享:

package com.design.interpreter;
public abstract class AbstractExpression {
    public abstract void interpret(Context context);
}

TerminalExpression（终端表达式）实现与语法终止符关联的解释操作，实现抽象表达式中所需的接口，并且主要是解释（）方法. 语法中的每个终端都有一个对应的特定终端表达式:

package com.design.interpreter;
public class TerminalExpression extends AbstractExpression{
    @Override
    public void interpret(Context context) {
        System.out.println("終結符解释器");
    }
}

NonterminalExpression（非终结符表达）为语法中的非终结符实现解释操作. 对于语法中的每个规则，都需要特定的非终止表达式类. 这是通过实现抽象表达式的解释（）方法来实现的. 解释操作，它递归地调用每个规则代表的符号的实例变量:

package com.design.interpreter;
public class NonterminalExpression extends AbstractExpression{
    @Override
    public void interpret(Context context) {
        System.out.println("非終結符解释器");
    }
}

上下文类（在解释器之外包含一些全局信息）:

package com.design.interpreter;
public class Context {
    private String input;
    private String output;
    Get&Set方法略… 
}

客户端以语法定义的语言构造表示特定句子的抽象语法的数量，并调用解释器操作:

package com.design.interpreter;
import java.util.ArrayList;
import java.util.List;
public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        List<AbstractExpression> list = new ArrayList<AbstractExpression>();
        list.add(new TerminalExpression());
        list.add(new NonterminalExpression());
        list.add(new TerminalExpression());
        list.add(new NonterminalExpression());
        for (AbstractExpression abstractExpression : list) {
            abstractExpression.interpret(context);
        }
    }
}

当有一种语言需要解释和执行时，您可以将该语言的句子表示为抽象语法树，则可以使用解释器模式.

使用解释器模式，您可以轻松更改和扩展语法，因为该模式使用类来表示语法规则，并且可以使用继承来更改或扩展语法. 语法也更容易实现，因为定义抽象语法树中每个节点的类通常是相似的，并且这些类很容易直接编写.

解释器模式的缺点: 语法中的每个规则至少定义了一个类，因为包含许多规则的语法可能难以维护和管理. 建议当语法非常复杂时，可以使用其他技术（例如解析器或编译器）来处理.

以手机铃声为例:

首先制定规则，S代表速度，500代表低速，1000代表中速，1500代表高速，O代表音阶，'O 1'代表低音阶，'O 2'代表中音阶，' “ O 3”代表高音阶，“ P”代表休息，“ CDEFGAB”代表音调，1代表一拍，0.5代表半拍，依此类推. 所有字母和数字用空格分隔. 例如: “ O 2 E 0.5 G 0.5 A 3 E 0.5”

性能内容上下文:

package com.design.interpret;
public class Context {
    //演奏文本
    private String playText ;  
    public String getPlayText() {
        return playText;
    }
    public void setPlayText(String playText) {
        this.playText = playText;
    }  
}

Expression类AbstractExpression:

package com.design.interpret;
public abstract class AbstractExpression {  
    //将演奏文本解析为对应的key和value，根据key值指定解释器
    public void interpret(Context context){
        if(context.getPlayText().length()==0){
            return;
        }
        //获取文本第一个字符作为key值
        String playText = context.getPlayText();
        String key = playText.substring(0,1);
        //获取key值后截取文本
        playText = playText.substring(2);
        //获取截取后文本第一个字段作为value值
        Double value = Double.parseDouble(playText.substring(0,playText.indexOf(" ")));
        //获取value值后截取文本
        playText = playText.substring(playText.indexOf(" ")+1);
        context.setPlayText(playText);
        //解释器执行
        excute(key, value);
    };   
    public abstract void excute(String key, Double value);
}  

NoteExpression:

package com.design.interpret;
public class NoteExpression extends AbstractExpression {  
    @Override
    public void excute(String key, Double value) {
        String note = "";
        switch (key) {
        case "C":
            note = "1";
            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;
        }
        System.out.print(note+" ");
    }  
}  

音调表达:

package com.design.interpret;
public class ScaleExpression extends AbstractExpression {
    @Override
    public void excute(String key, Double value) {
        String scale = "";
        switch (value.intValue()) {
        case 1:
            scale = "low";
            break;
        case 2:
            scale = "middle";
            break;
        case 3:
            scale = "high";
            break;
        }
        System.out.print(scale+" ");
    }  
}

SpeedExpression:

package com.design.interpret;
/**
 * 音速类
 * @author hydra
 *
 */
public class SpeedExpression extends AbstractExpression {
    @Override
    public void excute(String key, Double value) {
        String speed = "";
        switch (value.intValue()) {
        case 500:
            speed = "slow";
            break;
        case 1000:
            speed = "middle";
            break;
        case 1500:
            speed = "fast";
            break;
        }
        System.out.print(speed+" ");
    }
}

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-159999-1.html