mode interprète

Le modèle d'interprète fournit un moyen d'évaluer la grammaire ou les expressions d'une langue. Il s'agit d'un modèle comportemental. Ce modèle implémente une interface d'expression qui interprète un contexte spécifique. Ce mode est utilisé dans l'analyse SQL, les moteurs de traitement de symboles, etc.

Introduction

Intention : Étant donné une langue, définir sa représentation grammaticale et définir un interprète qui utilise cette représentation pour interpréter des phrases dans la langue.

Solution principale : Construire un interprète qui interprète les phrases pour une grammaire fixe.

Quand utiliser : Si un type particulier de problème se produit assez fréquemment, il peut être intéressant de formuler des instances individuelles de ce problème sous forme de phrase dans un langage simple. Cela permet de construire un interpréteur qui résout le problème en interprétant ces phrases.

Comment résoudre : Arbre de syntaxe des composants, définir les symboles terminaux et les symboles non terminaux.

Code clé : Classe d'environnement de composant, qui contient des informations globales en dehors de l'interpréteur, généralement HashMap.

Exemples d'application : Compilateur, calcul d'expression d'opération.

Avantages : 1. Bonne évolutivité et flexibilité. 2. Ajout d'une nouvelle façon d'interpréter les expressions. 3. Facile à mettre en œuvre une grammaire simple.

Inconvénients : 1. Il existe relativement peu de scénarios disponibles. 2. Il est difficile de maintenir une grammaire complexe. 3. Le mode interprète entraînera une expansion de la classe. 4. Le mode interprète utilise une méthode d'appel récursive.

Scénarios d'utilisation : 1. Une phrase dans un langage qui doit être interprétée et exécutée peut être représentée comme un arbre de syntaxe abstrait. 2. Certains problèmes récurrents peuvent être exprimés dans un langage simple. 3. Un scénario où une grammaire simple nécessite une explication.

Remarque : Il existe relativement peu de scénarios disponibles. Si vous le rencontrez en JAVA, vous pouvez utiliser expression4J à la place.

Implémentation

Nous allons créer une interface Expression et une classe d'entité qui implémente l'interface Expression. Définit la classe TerminalExpression qui sert d'interprète principal dans le contexte. Les autres classes OrExpression et AndExpression sont utilisées pour créer des expressions combinées.

InterpreterPatternDemo, notre classe de démonstration utilise 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 une classe d'entité qui implémente 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 Utilisez la classe Expression pour créer des règles et les analyser.

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

Étape 4

Vérifiez la sortie.

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