Design Patterns - Interpreter Pattern

Il pattern interprete fornisce un modo per valutare la grammatica o l'espressione della lingua. Questo tipo di modello rientra nel modello comportamentale. Questo modello implica l'implementazione di un'interfaccia di espressione che indica di interpretare un contesto particolare. Questo modello viene utilizzato nell'analisi SQL, nel motore di elaborazione dei simboli ecc.

Implementazione

Creeremo un'interfaccia Expression e classi concrete che implementano l' interfaccia Expression . Viene definita una classe TerminalExpression che funge da interprete principale del contesto in questione. Altre classi OrExpression , AndExpression vengono utilizzate per creare espressioni combinatorie.

InterpreterPatternDemo , la nostra classe demo, utilizzerà la classe Expression per creare regole e dimostrare l'analisi delle espressioni.

Passo 1

Crea un'interfaccia di espressione.

Expression.java

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

Passo 2

Crea classi concrete che implementano l'interfaccia 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);
   }
}

Passaggio 3

InterpreterPatternDemo utilizza la classe Expression per creare regole e quindi analizzarle.

InterpreterPatternDemo.java

public class InterpreterPatternDemo {

   //Rule: Robert and John are male
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);		
   }

   //Rule: Julie is a married women
   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"));
   }
}

Passaggio 4

Verifica l'output.

John is male? true
Julie is a married women? true