20. 解释器模式

### 20. 解释器模式
> 提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

- **主要解决**：对于一些固定文法构建一个解释句子的解释器。

以解释一句话为例，最小单元步骤：

- 1、创建一个表达式接口 Expression。

```java
	public interface Expression {
	    public boolean interpreter(String content);
	}
	```

- 2、创建实现了上述接口的实体类。TerminalExpression、OrExpression、AndExpression。

```java
	public class TerminalExpression implements Expression {
	
		private String data;
		
		public TerminalExpression(String data) {
		    this.data = data;
		}
		
		@Override
		public boolean interpreter(String content) {
		   // 是包含判断
		    return content.contains(data);
		}
	}
	```

```java
	public class OrExpression implements Expression {
	
	    private Expression expression1;
	    private Expression expression2;
	
	    public OrExpression(Expression expression1, Expression expression2) {
	        this.expression1 = expression1;
	        this.expression2 = expression2;
	    }
	
	    @Override
	    public boolean interpreter(String content) {
	        return expression1.interpreter(content) || expression2.interpreter(content);
	    }
	}
	```

```java
	public class AndExpression implements Expression {
	
	    private Expression expression1;
	    private Expression expression2;
	
	    public AndExpression(Expression expression1, Expression expression2) {
	        this.expression1 = expression1;
	        this.expression2 = expression2;
	    }
	
	    @Override
	    public boolean interpreter(String content) {
	        return expression1.interpreter(content) && expression2.interpreter(content);
	    }
	}
	```

- 3、使用 Expression 类来创建规则，并解析它们。

```java
    /**
     * 规则：jingbin 和 youlookwhat 是男性
     */
    public static Expression getMaleExpression() {
        TerminalExpression jingbin = new TerminalExpression("jingbin");
        TerminalExpression youlookwhat = new TerminalExpression("youlookwhat");
        return new OrExpression(jingbin, youlookwhat);
    }

/**
     * 规则：Julie 是一个已婚的女性
     */
    public static Expression getMarriedWomanExpression() {
        TerminalExpression julie = new TerminalExpression("Julie");
        TerminalExpression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

Expression maleExpression = getMaleExpression();
	// jingbin is male: true
	Log.e("---", "jingbin is male: " + maleExpression.interpreter("jingbin"));

Expression womanExpression = getMarriedWomanExpression();
    // Julie is married woman: true
    Log.e("---", "Julie is married woman: " + womanExpression.interpreter("Married Julie"));

```