解释器模式
解释器模式就是定义一种语言，并定义这个语言的解释器，解释器能够按照定义好的语法来将这种语言‘翻译’成使用者能理解的语言。
广泛上来讲，Java是一种定义的语言，JVM就是一种‘解释器’，而计算机就是最终的使用者。我们写一段Java代码，而计算机只认识0101的机器语言，JVM就是将Java代码解释成0101的机器语言让计算机能够理解并运行。
我们还是以我们实验室的实例来说明下这个模式。
最近我们实验室的兽人工厂拿到了老总的一个批示：
class LaoZong {
private String order = "MN1n2";
public String getOrder() {
return order;
}
public void setOrder(String order) {
this.order = order;
}
}
class ShouRenFactory {
public void readOrder() {
LaoZong lz = new LaoZong();
System.out.println(lz.getOrder());
}
}
public class Interpreter {
public static void main(String[] args) {
new ShouRenFactory().readOrder();
}
}
于是兽人工厂拿到老板的指令就是"MN1n2"。完全不明白要干什么，于是需要找老板秘书来解释下：
class ShouRenFactory {
public void readOrder() {
LaoZong lz = new LaoZong();
MiShu ms = new MiShu();
System.out.println(ms.translate(lz.getOrder()));
}
}
class MiShu {
public String translate(String order) {
//Black Box
String realWord = "生产男兽人1个女兽人2个";
return realWord;
}
}
现在我们兽人工厂终于知道了老总的命令:"生产男兽人1个女兽人2个",
但是秘书是怎么知道老总的命令的呢，如果兽人工厂也能知道秘书解析的过程，那就不用每次都麻烦秘书来解释了。毕竟秘书是老板用的，而不是兽人工厂用的。
请教秘书解析的方法：
秘书说她先判断每一个字幕或者数组是什么类型的命令，然后再用不同的解释方法解释不同的类型，比如说‘M’就是命令类的，‘Nn’是产品名称类的，数字就是数量类的。
于是兽人工厂就根据秘书的方法实现了自己的解析方式：
public class Interpreter {
public static void main(String[] args) {
new ShouRenFactory().readOrder();
}
}
class ShouRenFactory {
private String translate(String order) {
String realOrder = "";
//组装解释器
List<Expression> expressions = new ArrayList<Expression>();
expressions.add(new CommandExpression());
expressions.add(new ProductExpression());
expressions.add(new NumberExpression());
//挨个解释老总的命令
String[] codes = order.split("");
for (String code :codes) {
for (Expression expression : expressions) {
if (expression.matches(code)) {
realOrder += expression.excute(code);
break;
}
}
}
return realOrder;
}
public void readOrder() {
LaoZong lz = new LaoZong();
System.out.println(translate(lz.getOrder()));
}
}
abstract class Expression {
protected HashMap<String, String> map = new HashMap<String, String>();
private Set<String> getMarkers() {
return map.keySet();
}
public boolean matches(String code) {
return getMarkers().contains(code);
}
abstract public String excute(String code);
}
class CommandExpression extends Expression {
public CommandExpression() {
map.put("M", "创建");
map.put("D", "销毁");
map.put("E", "维修");
}
@Override
public String excute(String code) {
return map.get(code);
}
}
class ProductExpression extends Expression {
public ProductExpression() {
map.put("N", "男兽人");
map.put("n", "女兽人");
}
@Override
public String excute(String code) {
return map.get(code);
}
}
class NumberExpression extends Expression {
public NumberExpression() {
}
@Override
public boolean matches(String code) {
return code.matches("[0-9]");
}
@Override
public String excute(String code) {
return code + "个";
}
}
这样我们就实现了一个简单的解析器模式，在这种模式下，我们可以很简单的增加或者删除某种解析器。
解析器模式是一种易于理解但难于应用的模式。
除非在“一种特定类型的问题发生的频率足够高”的情况下，我们并不推荐使用此模式。因为当文法特别复杂时，会产生很多类，这对维护来说比较困难。总的来说在文法比较简单且发生频率很高的情况下才使用此模式。