简介:解释器模式是指给定一门语言,定义它的文法的一种表示(如:加减乘除表达式和正则表达式等),然后再定义一个解释器,该解释器用来解释我们的文法表示(表达式)。大白话就是给一个符号然后根据符号的不同做相应的动作
结构图:
![](https://i-blog.csdnimg.cn/blog_migrate/367da41062323a93487490a19b416fda.png)
抽象解释器:声明一个所有具体表达式都要实现的抽象接口(或者抽象类),接口中主要是一个interpret()方法,称为解释操作。具体解释任务由它的各个实现类来完成,具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器NonterminalExpression完成。
终结符表达式:实现与文法中的元素相关联的解释操作,通常一个解释器模式中只有一个终结符表达式,但有多个实例,对应不同的终结符。终结符一半是文法中的运算单元,比如有一个简单的公式R=R1+R2,在里面R1和R2就是终结符,对应的解析R1和R2的解释器就是终结符表达式。
非终结符表达式:文法中的每条规则对应于一个非终结符表达式,非终结符表达式一般是文法中的运算符或者其他关键字,比如公式R=R1+R2中,+就是非终结符,解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加,原则上每个文法规则都对应一个非终结符表达式。
环境角色:这个角色的任务一般是用来存放文法中各个终结符所对应的具体值,比如R=R1+R2,我们给R1赋值100,给R2赋值200。这些信息需要存放到环境角色中,很多情况下我们使用Map来充当环境角色就足够了。
代码:
package interpreter.vertion1;
import java.util.HashMap;
/**
* 指定抽象表达式,具体表达式必须实现的方法
* @author xingoo
*
*/
abstract class Expression{
/**
* 以上下文环境为准,解释指定的表达式
* @param ctx
* @return
*/
public abstract boolean interpret(Context ctx);
/**
* 检验两个表达式,是否相同
*/
public abstract boolean equals(Object o);
/**
* 返回表达式代表的hashCode
*/
public abstract int hashCode();
/**
* 转换成字符串
*/
public abstract String toString();
}
/**
* 常量表达式
* @author xingoo
*
*/
class Constant extends Expression{
private boolean value;
public Constant(boolean value){
this.value = value;
}
public boolean interpret(Context ctx){
return value;
}
public boolean equals(Object o){
if(o!=null && o instanceof Constant){
return this.value == ((Constant)o).value;
}
return false;
}
public int hashCode() {
return (this.toString()).hashCode();
}
public String toString() {
return new Boolean(value).toString();
}
}
/**
* 变量表达式
* @author xingoo
*
*/
class Variable extends Expression{
private String name;
public Variable(String name){
this.name = name;
}
public boolean interpret(Context ctx) {
return ctx.lookup(this);
}
public boolean equals(Object o) {
if(o!=null && o instanceof Variable){
return this.name.equals(((Variable)o).name);
}
return false;
}
public int hashCode() {
return (this.toString()).hashCode();
}
public String toString() {
return name;
}
}
/**
* 与 表达式
* @author xingoo
*
*/
class And extends Expression{
private Expression left,right;
public And(Expression left,Expression right){
this.left = left;
this.right = right;
}
public boolean interpret(Context ctx) {
return left.interpret(ctx) && right.interpret(ctx);
}
@Override
public boolean equals(Object o) {
if(o!=null && o instanceof And){
return this.left.equals(((And)o).left) && this.right.equals(((And)o).right);
}
return false;
}
public int hashCode() {
return (this.toString()).hashCode();
}
public String toString() {
return "("+left.toString()+" AND "+right.toString()+")";
}
}
/**
* 或 表达式
* @author xingoo
*
*/
class Or extends Expression{
private Expression left,right;
public Or(Expression left,Expression right){
this.left = left;
this.right = right;
}
public boolean interpret(Context ctx) {
return left.interpret(ctx) || right.interpret(ctx);
}
public boolean equals(Object o) {
if(o!=null && o instanceof Or){
return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
}
return false;
}
public int hashCode() {
return (this.toString()).hashCode();
}
public String toString() {
return "("+left.toString()+" Or "+right.toString()+")";
}
}
/**
* 非 表达式
* @author xingoo
*
*/
class Not extends Expression{
private Expression exp;
public Not(Expression exp){
this.exp = exp;
}
public boolean interpret(Context ctx) {
return !exp.interpret(ctx);
}
public boolean equals(Object o) {
if(o!=null && o instanceof Not){
return this.exp.equals(((Not)o).exp);
}
return false;
}
public int hashCode() {
return (this.toString()).hashCode();
}
public String toString() {
return "(Not "+exp.toString()+")";
}
}
/**
* 上下文环境
* @author xingoo
*
*/
class Context{
private HashMap map = new HashMap();
public void assign(Variable var,boolean value){
map.put(var, new Boolean(value));
}
public boolean lookup(Variable var) throws IllegalArgumentException{
Boolean value = (Boolean)map.get(var);
if(value == null){
throw new IllegalArgumentException();
}
return value.booleanValue();
}
}
public class Client {
private static Context ctx;
private static Expression exp;
public static void main(String[] args) {
ctx = new Context();
Variable x = new Variable("x");
Variable y = new Variable("y");
Constant c = new Constant(true);
//放入上下文中
ctx.assign(x, false);
ctx.assign(y, true);
exp = new Or(new And(c,x),new And(y,new Not(x)));
System.out.println("x = "+x.interpret(ctx));
System.out.println("y = "+y.interpret(ctx));
System.out.println(exp.toString() +" = "+exp.interpret(ctx));
/**
* x = false
* y = true
* ((true AND x) Or (y AND (Not x))) = true
*/
}
}