padrão Interpreter

padrão de intérprete (Padrão intérprete) fornece uma maneira de avaliar a sintaxe de expressão ou de linguagem, que pertence ao tipo de modelo. Esse modo implementa uma interface expressão que explicar um contexto particular. Este modelo é utilizado na análise SQL, os motores de processamento de símbolo.

introdução

Intenção: Dada uma linguagem, definir a sua representação gramática, e definir um intérprete, o intérprete usa o logotipo de interpretar frases na língua.

Solução principal: Por alguma gramática fixa construção de uma frase para explicar intérprete.

Quando se deve utilizar: Se a frequência de um determinado tipo de problema é suficientemente alta, pode valer a pena cada instância do problema é expressa como uma simples frases na língua.De modo que você pode construir um intérprete, o intérprete para resolver o problema através da interpretação destas frases.

Como corrigir: árvore de sintaxe membro, a definição do terminador e não-terminal.

A chave código: ambiente de classe membro, algumas informações globais contidas intérprete do lado de fora, geralmente HashMap.

Exemplos de aplicação: compilador, a avaliação da expressão aritmética.

Vantagens: 1, melhor escalabilidade e flexíveis.2, adicionou uma nova maneira de interpretar a expressão. 3, fácil de implementar gramática simples.

Desvantagens: 1, pode tirar proveito da cena é relativamente pequeno.2. Para complexo gramáticas mais difícil de manter. 3 explica o modo fará com que a classe de expandir. 4 explicar o modo usando chamadas de método recursivo.

cenários de uso: 1 pode ser interpretada de sentenças de linguagem deve ser representado por uma árvore de sintaxe abstrata.2, alguns dos problemas recorrentes pode ser uma linguagem simples para expressar. 3, uma gramática simples de explicar a cena.

Nota: Você pode usar relativamente pequena cena, JAVA, se você encontrar pode expression4J vez.

realização

Vamos criar e implementar uma interface classe de entidadeExpressionInterfaceExpression.Conforme definido no contexto deTerminalExpressionintérprete principal. Outras classesOrExpression,AndExpression para a criação de expressões modulares.

InterpreterPatternDemo,a nossa classe demonstração usaaclasse daexpressãopara criar regras de análise e expressões de apresentação.

passo 1

Criar uma interface de expressão.

Expression.java

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

passo 2

Criar classe de entidade implementa as interfaces acima.

TerminalExpression.java

public class TerminalExpression implements Expression {
	
   private String data;

   public TerminalExpression(String data){
      this.data = data; 
   }

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

OrExpression.java

public class OrExpression implements Expression {
	 
   private Expression expr1 = null;
   private Expression expr2 = null;

   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {		
      return expr1.interpret(context) || expr2.interpret(context);
   }
}

AndExpression.java

public class AndExpression implements Expression {
	 
   private Expression expr1 = null;
   private Expression expr2 = null;

   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }

   @Override
   public boolean interpret(String context) {		
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

passo 3

InterpreterPatternDemousar a classede expressõespara criar regras e resolvê-los.

InterpreterPatternDemo.java

public class InterpreterPatternDemo {

   //规则：Robert 和 John 是男性
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);		
   }

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

   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();

      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " 
      + isMarriedWoman.interpret("Married Julie"));
   }
}

passo 4

Verifique saída.

John é do sexo masculino? Verdadeiro
Julie é uma mulher casada? Verdadeiro