设计模式-解释器模式

最新推荐文章于 2024-09-02 00:00:00 发布

极客编程玩家

最新推荐文章于 2024-09-02 00:00:00 发布

阅读量237

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/lzy_zhi_yuan/article/details/76522273

版权

设计模式专栏收录该内容

19 篇文章 0 订阅

订阅专栏

设计模式-解释器模式

1、概念

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

2、优点

1、可扩展性比较好，灵活。

2、增加了新的解释表达式的方式。

3、易于实现简单文法。

3、缺点

1、可利用场景比较少。

2、对于复杂的文法比较难维护。

3、解释器模式会引起类膨胀。

4、解释器模式采用递归调用方法。

4、角色

1.AbstractExpression抽象解释器：具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和
NonterminalExpression
2.TerminalExpression终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结
表达式，但有多个实例，对应不同的终结符。
3.NonterminalExpression非终结符表达式：文法中的每条规则对应于一个非终结表达式，非终结符表达式根据逻辑的
复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式
4.Context环境角色

5、使用场景

1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

2、一些重复出现的问题可以用一种简单的语言来进行表达。

3、一个简单语法需要解释的场景。

6、案例描述

将类似C#代码转换为Java代码

7、UML类图

8、代码解析UML类图

AbstractExpression：

/**
 * Created by laizhiyuan on 2017/8/1.
 *
 * <p>
 *     设计模式-解释器模式-抽象解释器（语法装换器）
 * </p>
 */
public abstract class AbstractConversionExpression {

    public abstract String conversion(Context content);
}

TerminalExpression：

/**
 * Created by laizhiyuan on 2017/8/1.
 *
 * <p>
 *     设计模式-解释器模式-终结符（字符串）
 * </p>
 */
public class StringTerminaExpression extends AbstractConversionExpression{

    private String str;

    public StringTerminaExpression(String str) {
        this.str = str;
    }

    public String getStr() {
        return str;
    }

    @Override
    public String conversion(Context content) {
        return str;
    }
}

NonterminalExpression：

/**
 * Created by laizhiyuan on 2017/8/1.
 */
public class TypeConversionNonterminalExpression extends AbstractConversionExpression {

    private AbstractConversionExpression mainExpression;
    private AbstractConversionExpression constantExpression;
    public TypeConversionNonterminalExpression(AbstractConversionExpression mainExpression,
                                                  AbstractConversionExpression constantExpression) {
        this.mainExpression = mainExpression;
        this.constantExpression = constantExpression;
    }

    @Override
    public String conversion(Context context) {

        if (mainExpression.conversion(context).indexOf(constantExpression.conversion(context)) != -1){
            int index = mainExpression.conversion(context).indexOf(constantExpression.conversion(context));
            StringBuilder stringBuilder = new StringBuilder(mainExpression.conversion(context).substring(0, index))
                    .append(context.get(constantExpression).conversion(context))
                    .append(" ")
                    .append(mainExpression.conversion(context).substring(index + 7, mainExpression.conversion(context).length()));

            return stringBuilder.toString();
        }
        return mainExpression.conversion(context);
    }
}

/**
 * Created by laizhiyuan on 2017/8/1.
 *
 * <p>
 *     设计模式-解释器模式-非终结符（继承字符串装换）
 * </p>
 */
public class ExtendsConversionNonterminalExpression extends AbstractConversionExpression {

    private AbstractConversionExpression mainExpression;
    private AbstractConversionExpression constantExpression;
    public ExtendsConversionNonterminalExpression(AbstractConversionExpression mainExpression,
                                                  AbstractConversionExpression constantExpression) {
        this.mainExpression = mainExpression;
        this.constantExpression = constantExpression;
    }

    @Override
    public String conversion(Context context) {

        if (mainExpression.conversion(context).indexOf(constantExpression.conversion(context)) != -1){
            int index = mainExpression.conversion(context).indexOf(constantExpression.conversion(context));

            StringBuilder stringBuilder = new StringBuilder(mainExpression.conversion(context).substring(0, index))
                    .append(context.get(constantExpression).conversion(context))
                    .append(mainExpression.conversion(context).substring(index + 1, mainExpression.conversion(context).length()));

            return stringBuilder.toString();
        }
        return mainExpression.conversion(context);
    }


}

Context：

/**
 * Created by laizhiyuan on 2017/8/1.
 *
 * <p>
 *     设计模式-解释器模式-上下文
 * </p>
 */
public class Context {

    private Map<AbstractConversionExpression, AbstractConversionExpression>
            context = new HashMap<AbstractConversionExpression, AbstractConversionExpression>();

    public void put(AbstractConversionExpression key, AbstractConversionExpression value){
        context.put(key, value);
    }

    public AbstractConversionExpression get(AbstractConversionExpression key){
        AbstractConversionExpression expression = context.get(key);
        if (expression == null){
            for (AbstractConversionExpression nKey : context.keySet()){
                if (key.conversion(this).indexOf(nKey.conversion(this)) != -1){
                    return context.get(nKey);
                }
            }
        }
        return expression;
    }

}

工具类：

/**
 * Created by laizhiyuan on 2017/08/01
 */
public class HandleTextFileUtil extends ArrayList<String>{

    public static String read(String fileName){

        if ("".equals(fileName)){
            return "";
        }

        StringBuilder sb = new StringBuilder();
        try {
            BufferedReader br = new BufferedReader(new FileReader(new File(fileName).getAbsoluteFile()));
            String s ;
            try {
                while ((s = br.readLine()) != null ){
                    sb.append(s).append("\n");
                }

                return sb.toString();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }finally{
                if (br != null){
                    try {
                        System.out.print("close buffered reader");
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static void write(String fileName, String text){

        if ("".equals(fileName) || "".equals(text)){
            return;
        }

        try {
            PrintWriter pw = new PrintWriter(new File(fileName).getAbsoluteFile());
            try{
                pw.println(text);
            }finally {
                if (pw != null){
                    pw.close();
                }
            }

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public void write(String fileName){
        if ("".equals(fileName)){
            return;
        }

        try {
            PrintWriter pw = new PrintWriter(new File(fileName).getAbsoluteFile());
            try{
                for (String item : this){
                    pw.println(item);
                }
                pw.flush();
            }finally {
                System.out.print("close write");
                pw.close();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public HandleTextFileUtil(String fileName, String split){
        super(Arrays.asList(read(fileName).split(split)));
        if (get(0).equals(""))
            remove(0);
    }

    public HandleTextFileUtil(String fileNamee){
        this(fileNamee,"\n");
    }

}

9、测试

/**
 * Created by laizhiyuan on 2017/8/1.
 */
public class Main {

    public static void main(String[] args) {
        String path = "D:\\Hello.cs";
        File file = new File("D:\\Hello.java");
        try {
            file.delete();
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        HandleTextFileUtil handleTextFileUtil = new HandleTextFileUtil(path);

        Context context = new Context();
        AbstractConversionExpression cExtendsStr = new StringTerminaExpression(":");
        AbstractConversionExpression javaExtendsStr = new StringTerminaExpression("extends");
        AbstractConversionExpression cStringTypeStr = new StringTerminaExpression("string");
        AbstractConversionExpression javaStringTypeStr = new StringTerminaExpression("String");

        context.put(cExtendsStr, javaExtendsStr);
        context.put(cStringTypeStr, javaStringTypeStr);

        AbstractConversionExpression expression = null;
        AbstractConversionExpression mainExpression = null;
        for (int i = 0; i < handleTextFileUtil.size(); i++){
            mainExpression = new StringTerminaExpression(handleTextFileUtil.get(i));
            if (mainExpression.conversion(context).indexOf(cExtendsStr.conversion(context)) != -1){
                expression = new ExtendsConversionNonterminalExpression(mainExpression, cExtendsStr);
                handleTextFileUtil.set(i, expression.conversion(context));
            }else if (mainExpression.conversion(context).indexOf(cStringTypeStr.conversion(context)) != -1){
                expression = new TypeConversionNonterminalExpression(mainExpression, cStringTypeStr);
                expression.conversion(context);
                handleTextFileUtil.set(i, expression.conversion(context));
            }

        }
        handleTextFileUtil.write("D:\\Hello.java");
    }
}

10、测试结果

测试源文件：

class Hello : World{

private string name;

public void setName(string name){

this.name = name;
}

public string getName(){

return this.name;

}

}

解释后的文件

class Hello extends World{

private String name;

public void setName(String name){

this.name = name;
}

public String getName(){

return this.name;

}

}