设计模式之解释器模式

        假如有一天，老师给一篇文章，需要对其进行不同的处理，我们可以在一个类中利用不同方法实现，但是这个类就显得冗余。我们在设计中，有一个设计原则叫做单一责任原则，即尽可能一个类代表一个功能。那么，我们这里需要将每一种处理都提取出来定义成一个类。可能老师会让你把中文文章翻译成日文，还要翻译成英文等等，那么我们可以将每一种语言变成一个类。这样方便统一操作。这也就是解释器的操作原理，将每种语言定义成一个解释器，然后可以利用解释器来表示语言中的句子，达到翻译效果。解释器模式是一个平时用的比较少的模式，它是给定一个语言，定义它的文法的一种表示，并定义一个解释器，使用该解释器来表示语言中的句子。

1.适用性和优缺点

1.适用性

当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树，可使用解释器模式，当存在以下情况时该模式效果最好：

a.该文法简单，对于复杂的文法，文法的类层次变得无法管理

b.效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。

2.优点

a.将每一个语法规则表示成一个类，方便于实现语言。

b.因为语法由许多类表示，可以轻易地改变或扩展此语言。

c.通过在类结构中加入新的方法，可以在解释的同时增加新的行为。

3.缺点

当语法规则的数目太大时，这个模式可能会变得非常繁杂。

2.示例讲解

UML图：

                      

Expression：声明一个抽象的解释器操作，这个接口为抽象语法树中所有的节点所共享。

ConcreteExpression：具体的解释器操作，有一个interpret方法，需要传入一个Context对象，即传入字符串输入流，便于进行解释器操作。

Context:该类是为了引入我们解释器所需要的字符串输入流，然后可以添加不同种类的解释器(通过建立列表),可以包含解释器之外的全局信息。

        接下来，我们来看一个具体例子，该例子主要讲的是简单的句子转换。

首先定义一个解释器接口，Expression抽象类。

package interpreterpattern;

public abstract class Expression {

    abstract void interpret(Context ctx);
}

然后，实现几个具体的解释器，主要是全部转化为大写字母，全部转化为小写字母，句子反转三类，这三个解释器类，都实现了interpret方法，并且该方法需要一个Context对象，相应的类在后面给出。

package interpreterpattern;

public class UpperExpression extends Expression {

	@Override
	void interpret(Context ctx) {
		// TODO Auto-generated method stub
		String content=ctx.getContent();
		String upperContent=content.toUpperCase();
		System.out.println("这段话全部大写是："+upperContent);

	}

}

package interpreterpattern;

public class LowerExpression extends Expression {

	@Override
	void interpret(Context ctx) {
		// TODO Auto-generated method stub
		String content=ctx.getContent();
		String lowerContent=content.toLowerCase();
		System.out.println("这段话全部小写是："+lowerContent);

	}

}

package interpreterpattern;
import java.util.*;
public class RerverseExpression extends Expression {

	@Override
	void interpret(Context ctx) {
		// TODO Auto-generated method stub
		String context=ctx.getContent();
		StringBuilder sb=new StringBuilder(context);
		String reverseContent=sb.reverse().toString();
		System.out.println("这段话倒过来是："+reverseContent);

	}

}

接着建立一个Context类，该类需要传入解释器的interpret方法中，同时这个例子中再Context类中添加一个列表用于保存解释器对象。

package interpreterpattern;
import java.util.*;
public class Context {

    private String content;
    
    private List<Expression> list ;
    //初始化
    public Context(String content)
    {
    	list= new ArrayList<Expression>();
    	this.content=content;
    }
    
    
    public String getContent() {
        return this.content;
    }
    
    public void add(Expression eps) {
        list.add(eps);
    }
    
    public List<Expression> getList() {
        return this.list;
    }
}

最后就是客户端代码：

package interpreterpattern;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String content="I'm Carson,I'm from China!";
		Context ctx=new Context(content);
		ctx.add(new UpperExpression());
		ctx.add(new LowerExpression());
		ctx.add(new RerverseExpression());
		
		for(Expression eps:ctx.getList())
		{
			eps.interpret(ctx);
		}
		
		

	}

}

运行结果如下：

这段话全部大写是：I'M CARSON,I'M FROM CHINA!
这段话全部小写是：i'm carson,i'm from china!
这段话倒过来是：!anihC morf m'I,nosraC m'I

        以上便是解释器的例子，解释器的核心是将每一种语法定义成一个解释器，并且需要在解释器的interpret方法中传入Context对象。