Java: Interpreter Pattern

 

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc Expression.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */

package com.javapatterns.interpreter;

/**
 *
 *
 * */
public abstract  class Expression {

    /**
     * Given a BooleanExp object denoting a term,
     * this method interprets this term relative to a Context
     * object.
     */
    public abstract boolean interpret(Context ctx);

    /**
     * Given a BooleanExp object denoting a term,
     * this method test whether the given argument
     * denoting another term is structurally the same.
     */
    public abstract boolean equals(Object o);

    /**
     * Returns a hash code of this term.
     */
    public abstract int hashCode();

    /**
     * Converts a term into a string. Can be used as the
     * basis for calculating the hashCode.
     */
    public abstract String toString();



}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc Context.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */

package com.javapatterns.interpreter;


import java.util.HashMap;

/**
 *
 *
 * */
public 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();
    }
}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc Variable.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */


package com.javapatterns.interpreter;
/**
 *
 *
 * */
public 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;
    }

}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc Constant.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */

package com.javapatterns.interpreter;
/**
 *
 *
 * */
public 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();
    }
}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc DuAnd.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */

package com.javapatterns.interpreter;
/**
 *
 *
 * */
public class DuAnd extends Expression{

    /**
     *
     *
     * */
    private Expression left, right;
    /**
     *
     *
     * */
    public DuAnd(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 DuAnd)
        {
            return this.left.equals(((DuAnd) o).left) &&
                    this.right.equals(((DuAnd) o).right);
        }
        return false;
    }
    /**
     *
     *
     * */
    public int hashCode()
    {
        return (this.toString()).hashCode();
    }
    /**
     *
     *
     * */
    public String toString()
    {
        return "(" + left.toString() + " AND " + right.toString() + ")";
    }
}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc DuNot.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */

package com.javapatterns.interpreter;
/**
 *
 *
 * */
public class DuNot extends Expression{

    /**
     *
     *
     * */
    private Expression exp;
    /**
     *
     *
     * */
    public DuNot(Expression exp)
    {
        this.exp = exp;
    }
    /**
     *
     *
     * */
    public boolean interpret(Context ctx)
    {
        return !exp.interpret(ctx);
    }
    /**
     *
     *
     * */
    public boolean equals(Object o)
    {
        if (o != null && o instanceof DuNot)
        {
            return this.exp.equals(((DuNot) o).exp);
        }
        return false;
    }
    /**
     *
     *
     * */
    public int hashCode()
    {
        return (this.toString()).hashCode();
    }
    /**
     *
     *
     * */
    public String toString()
    {
        return " (Not " + exp.toString() + ")";
    }
}

　　

/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 解释器模式 Interpreter Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 *javadoc - -encoding Utf-8 -d apidoc DuOr.java
 * Interface
 * Record
 * Annotation
 * Enum
 * */


package com.javapatterns.interpreter;
/**
 *
 *
 * */
public class DuOr extends Expression{
    /**
     *
     *
     * */
    private Expression left, right;
    /**
     *
     *
     * */
    public DuOr(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 DuOr)
        {
            return this.left.equals(((DuOr) o).left) &&
                    this.right.equals(((DuOr) o).right);
        }
        return false;
    }
    /**
     *
     *
     * */
    public int hashCode()
    {
        return (this.toString()).hashCode();
    }
    /**
     *
     *
     * */
    public String toString()
    {
        return "(" + left.toString() + " OR " + right.toString() + ")";
    }
}

　　

调用：

            //解释器模式
            Context ctx;
            Expression exp ;
            ctx = new Context();
            Variable x = new Variable("x");
            Variable y = new Variable("y");
            Constant ducc = new Constant(true);
            ctx.assign(x, false);
            ctx.assign(y, true);
            exp = new DuOr( new DuAnd(ducc, x) , new DuAnd(y, new DuNot(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