Entwurfsmuster - Interpretermuster

Das Interpreter-Muster bietet eine Möglichkeit, die Sprachgrammatik oder den Ausdruck zu bewerten. Diese Art von Muster fällt unter Verhaltensmuster. Dieses Muster beinhaltet die Implementierung einer Ausdrucksschnittstelle, die angibt, einen bestimmten Kontext zu interpretieren. Dieses Muster wird beim SQL-Parsing, bei der Symbolverarbeitungsengine usw. verwendet.

Implementierung

Wir werden eine Schnittstelle Expression und konkrete Klassen erstellen, die die Expression- Schnittstelle implementieren . Es ist eine Klasse TerminalExpression definiert, die als Hauptinterpreter des betreffenden Kontexts fungiert. Andere Klassen OrExpression , AndExpression werden verwendet, um kombinatorische Ausdrücke zu erstellen.

InterpreterPatternDemo , unsere Demo-Klasse, verwendet die Expression- Klasse, um Regeln zu erstellen und das Parsen von Ausdrücken zu demonstrieren.

Schritt 1

Erstellen Sie eine Ausdrucksschnittstelle.

Expression.java

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

Schritt 2

Erstellen Sie konkrete Klassen, die die obige Schnittstelle implementieren.

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

Schritt 3

InterpreterPatternDemo verwendet die Expression- Klasse, um Regeln zu erstellen und diese dann zu analysieren.

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

Schritt 4

Überprüfen Sie die Ausgabe.

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