modello interprete

modello Interpreter (interprete Pattern) fornisce un modo per valutare la sintassi delle espressioni o la lingua, che appartiene al tipo di modello. Questa modalità implementa un'interfaccia un'espressione che spiegare un particolare contesto. Questo modello è utilizzato nel parsing SQL, motori simbolo elaborazione.

introduzione

Intento: Dato un linguaggio, a definire la sua rappresentazione della grammatica, e definire un interprete, l'interprete utilizza il logo per interpretare le frasi nella lingua.

Soluzione principale: Per alcuni la grammatica fissa la costruzione di una frase per spiegare interprete.

Quando utilizzare: Se la frequenza di un particolare tipo di problema è sufficientemente elevato, può essere opportuno ogni istanza del problema è espresso come un semplice frasi nella lingua.In modo che si può costruire un interprete, l'interprete per risolvere il problema interpretando queste frasi.

Come risolvere: albero di sintassi membro, la definizione di terminazione e non terminale.

La chiave codice: ambiente i membri della classe, alcune informazioni contenute globale interprete di fuori, di solito HashMap.

Esempi di applicazione: compilatore, valutazione delle espressioni aritmetiche.

Vantaggi: 1, una migliore scalabilità e flessibilità.2, ha aggiunto un nuovo modo di interpretare l'espressione. 3, facile da implementare semplice grammatica.

Svantaggi: 1, possono usufruire della scena è relativamente piccolo.2. Per complesso grammatiche più difficile da mantenere. 3 a spiegare il modo farà sì che la classe di espandersi. 4 spiegare la modalità utilizzando chiamate metodo ricorsivo.

scenari di utilizzo: 1 possono essere interpretati a frasi lingua devono essere rappresentate da un albero di sintassi astratta.2, alcuni dei problemi ricorrenti può essere un linguaggio semplice per esprimere. 3, una semplice grammatica per spiegare la scena.

Nota: È possibile utilizzare relativamente piccola scena, JAVA se incontrate possono expression4J invece.

realizzazione

Creeremo e implementare un'interfaccia classe di entitàEspressioneinterfacciaEspressione.Come definito nel contesto diTerminalExpressioninterprete principale. Altre classi diOrExpression,AndExpression per la creazione di espressioni modulari.

InterpreterPatternDemo,la nostra classe dimostrazione utilizza classedi espressioniper creare regole di analisi e le espressioni di presentazione.

fase 1

Creare un'interfaccia espressione.

Expression.java

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

fase 2

Crea classe di entità implementa le interfacce di cui sopra.

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

fase 3

InterpreterPatternDemoutilizzare la classedi espressioniper creare regole e risolverli.

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

fase 4

Verifica uscita.

John è maschio? Vero
Julie è una donna sposata? Vero