patrón de intérprete

patrón intérprete (Pattern Intérprete) proporciona una manera de evaluar la sintaxis de la expresión o lenguaje, que pertenece al tipo de modelo. Este modo implementa una interfaz expresión que explica un contexto particular. Este modelo se utiliza en el análisis sintáctico SQL, motores de procesamiento de símbolos.

introducción

Intención: Dado un lenguaje, define su representación gramática, y definir un intérprete, el intérprete utiliza el logotipo de interpretar frases en el idioma.

Solución principal: Por alguna gramática fija la construcción de una frase para explicar intérprete.

Cuándo usar: Si la frecuencia de un determinado tipo de problema es suficientemente alta, puede valer la pena cada instancia del problema se expresa como un simple frases en el idioma.Por lo que se puede construir un intérprete, el intérprete de resolver el problema mediante la interpretación de estas frases.

Cómo corregir: árbol sintáctico miembro, la definición de terminador y no terminal.

El chip de codificación: entorno de clase de miembro, cierta información contenida mundial intérprete exterior, por lo general HashMap.

Ejemplos de aplicación: compilador, la evaluación de expresiones aritméticas.

Ventajas: 1, mejor escalabilidad y flexibilidad.2, añade una nueva manera de interpretar la expresión. 3, fácil de poner en práctica la gramática sencilla.

Desventajas: 1, se puede hacer uso de la escena es relativamente pequeño.2. Para las gramáticas complejo más difícil de mantener. 3 a explicar el modo hace que la clase se expanda. 4 explicar el modo de utilizar las llamadas a métodos recursivos.

Escenarios de uso: 1 puede interpretarse a las oraciones del lenguaje deberán estar representadas por un árbol de sintaxis abstracta.2, algunos de los problemas recurrentes puede ser un lenguaje sencillo para expresar. 3, una gramática sencilla de explicar la escena.

Nota: Puede utilizar relativamente pequeña escena, si se encuentra con JAVA puede expression4J lugar.

realización

Vamos a crear e implementar una interfaz de clase entidadExpresiónExpresión interfaz. Tal como se define en el contexto deTerminalExpressionintérprete principal. Otras clasesOrExpression,AndExpression para la creación de expresiones modulares.

InterpreterPatternDemo,nuestra clasededemostración utiliza la clasede expresionespara crear reglas de análisis y expresiones de presentación.

Paso 1

Crear una interfaz expresión.

Expression.java

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

Paso 2

Crear clase de entidad implementa las interfaces anteriores.

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);
   }
}

paso 3

InterpreterPatternDemoutilizar la clasede expresionespara crear reglas y resolverlos.

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"));
   }
}

Paso 4

Verifique la salida.

John es un hombre? Verdadero
Julie es una mujer casada? Verdadero