Java设计模式 - 解释器模式

背景

变形能够改变形态，进而各个属性都有所改变。合体将多个机体组合起来，变得更加强大。本案例模拟变形和合体的运算，来实现解释者模式。

实现

表达式接口

public interface Expression {

	String interpreter();
	
}

终结表达式：代表着机体的名称

/**
 * 终结符：代表着机体的名称
 */
public class RobotTerminalExpression implements Expression {
	
	private String name;
	
	public RobotTerminalExpression(String name) {
		super();
		this.name = name;
	}

	@Override
	public String interpreter() {
		return name;
	}

}

非终结表达式：变形

/**
 * 非终结符：变形操作
 */
public class TransformNonTerminalExpression implements Expression {
	
	private Expression exp;

	public TransformNonTerminalExpression(Expression exp) {
		super();
		this.exp = exp;
	}

	public Expression getExp() {
		return exp;
	}

	public void setExp(Expression exp) {
		this.exp = exp;
	}

	@Override
	public String interpreter() {
		String transformTo = "";
		switch (exp.interpreter()) {
		case "R1":
			transformTo = "R-Wing";
			break;
		case "野生兽":
			transformTo = "野生兽(FM)";
			break;
		default:
			transformTo = "非法的变形操作！";
			break;
		}
		
		return transformTo;
	}

}

非终结表达式：合体

/**
 * 非终结符-》合体操作
 */
public class CombineNonTerminalExpression implements Expression {
	
	private Expression exp1;
	
	private Expression exp2;
	
	private Expression exp3;
	
	public CombineNonTerminalExpression(Expression exp1, Expression exp2) {
		super();
		this.exp1 = exp1;
		this.exp2 = exp2;
	}

	public CombineNonTerminalExpression(Expression exp1, Expression exp2, Expression exp3) {
		super();
		this.exp1 = exp1;
		this.exp2 = exp2;
		this.exp3 = exp3;
	}

	@Override
	public String interpreter() {
		if ("R1".equals(exp1.interpreter()) && "R2".equals(exp2.interpreter()) && "R3".equals(exp3 == null? "" : exp3.interpreter())) {
			return "SRW";
		} else if ("Gunner".equals(exp1.interpreter()) && "晓击霸MKII-R".equals(exp2.interpreter())) {
			return "MKII-Gunner";
		} else {
			return "非法的合体操作！";
		}
	}

}

测试

public class Test {

	public static void main(String[] args) {
		// 终结符
		Expression ancientIronExpression = new RobotTerminalExpression("古铁");
		Expression r1Expression = new RobotTerminalExpression("R1");
		Expression r2Expression = new RobotTerminalExpression("R2");
		Expression r3Expression = new RobotTerminalExpression("R3");
		Expression gunnerExpression = new RobotTerminalExpression("Gunner");
		Expression mkiiExpression = new RobotTerminalExpression("晓击霸MKII-R");
		Expression wildExpression = new RobotTerminalExpression("野生兽");
		
		// 测试变形
		TransformNonTerminalExpression transformExpression = new TransformNonTerminalExpression(ancientIronExpression);
		System.out.println("古铁 变形->" + transformExpression.interpreter());
		transformExpression.setExp(r1Expression);
		System.out.println("R1 变形->" +transformExpression.interpreter());
		transformExpression.setExp(wildExpression);
		System.out.println("野生兽 变形->" +transformExpression.interpreter());
		
		System.out.println("-----------------");
		// 测试合体
		CombineNonTerminalExpression combineExpression = new CombineNonTerminalExpression(gunnerExpression, mkiiExpression);
		System.out.println("Gunner 合体  晓击霸MKII-R->" + combineExpression.interpreter());
		combineExpression = new CombineNonTerminalExpression(r1Expression, r2Expression, r3Expression);
		System.out.println("R1 合体  R2 合体 R3->" + combineExpression.interpreter());
		combineExpression = new CombineNonTerminalExpression(r1Expression, r2Expression);
		System.out.println("R1 合体  R2->" + combineExpression.interpreter());
	}
	
}

测试结果

古铁 变形->非法的变形操作！
R1 变形->R-Wing
野生兽 变形->野生兽(FM)
-----------------
Gunner 合体  晓击霸MKII-R->MKII-Gunner
R1 合体  R2 合体 R3->SRW
R1 合体  R2->非法的合体操作！

总结

22个设计模式的最后一个–解释器模式，也是比较难理解的一个，为了不使用运算符这个例子，我想到了机体的变形和合体操作，近似把它看成运算符，例子可能不是那么合适。

22篇文章实际上是一个月的时间内断断续续赶出来的，也没去深究各个模式的具体应用场景和优缺点，所以这些文章会不断的修改和完善，错误之处难免，希望看官持批判的态度看待这些文章。

如果你没有玩过这款游戏，有些情节可能不会有共鸣之处。
这是一款你没有玩过的创新版本，只需体验三分钟，你就会和我一样爱上这款游戏 – by zzh