Modèles de conception - Modèle d'interprétation

Le modèle d'interprétation fournit un moyen d'évaluer la grammaire ou l'expression d'une langue. Ce type de modèle relève du modèle comportemental. Ce modèle implique l'implémentation d'une interface d'expression qui dit d'interpréter un contexte particulier. Ce modèle est utilisé dans l'analyse SQL, le moteur de traitement de symboles, etc.

la mise en oeuvre

Nous allons créer une interface Expression et des classes concrètes implémentant l' interface Expression . Une classe TerminalExpression est définie qui agit comme un interprète principal du contexte en question. D'autres classes OrExpression , AndExpression sont utilisées pour créer des expressions combinatoires.

InterpreterPatternDemo , notre classe de démonstration, utilisera la classe Expression pour créer des règles et démontrer l'analyse des expressions.

Étape 1

Créez une interface d'expression.

Expression.java

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

Étape 2

Créez des classes concrètes mettant en œuvre l'interface ci-dessus.

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

Étape 3

InterpreterPatternDemo utilise la classe Expression pour créer des règles, puis les analyser.

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

Étape 4

Vérifiez la sortie.

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