解释器模式

一般用在语法树解析，或者a+c-d这种代数解析

第一步，写一个表达式

public interface Expression {
    boolean interpret(String info);
}

第二步，具体化为2实现类（这两个实现类有点个性）（一个有集合，一个要罗列所有表达式）

public class TerminalExpression implements Expression{
    //其中一个类有一个集合，就这个设成有集合的
    private Set<String> set= new HashSet<String>();

    //循环构造初始化值
    public TerminalExpression(String[] data)
    {
        for(int i=0;i<data.length;i++)set.add(data[i]);
    }

    @Override
    public boolean interpret(String info) {
        if (set.contains(info)) {
            return true;
        }
        return false;
    }
}

public class AndExpression implements Expression{
    private Expression city=null;//罗列表达式
    private Expression person=null;

    public AndExpression(Expression city,Expression person)
    {
        this.city=city;
        this.person=person;
    }

    @Override
    public boolean interpret(String info) {
        String s[]=info.split("的");//分割字符串
        return city.interpret(s[0])&&person.interpret(s[1]);
    }
}

环境类，提供公有变量

public class Context {
    private String[] citys={"深圳","广州"};
    private String[] persons={"老人","妇女","儿童"};
    private Expression cityPerson;

    public Context()
    {
        //构造时候初始化
        Expression city=new TerminalExpression(citys);
        Expression person=new TerminalExpression(persons);
        cityPerson=new AndExpression(city,person);
    }



    public void freeRide(String info)
    {
        //对传入的表达式解析
        boolean ok=cityPerson.interpret(info);
        if(ok) System.out.println("您是"+info+"，您本次乘车免费！");
        else System.out.println(info+"，您不是免费人员，本次乘车扣费2元！");
    }
}

最后测试类

public class Client {
    public static void main(String[] args) {
        Context bus=new Context();
        bus.freeRide("深圳的老人");
        bus.freeRide("深圳的年轻人");
        bus.freeRide("广州的妇女");
        bus.freeRide("广州的儿童");
        bus.freeRide("山东的儿童");
        bus.freeRide("北京的儿童");
    }
}