motif interprète

motif Interprète (Interprète Pattern) fournit une manière d'évaluer la syntaxe ou la langue d'expression, qui appartient au type de modèle. Ce mode implémente une interface d'expression qui expliquent un contexte particulier. Ce modèle est utilisé dans l'analyse syntaxique de données SQL, les moteurs de traitement de symboles.

introduction

Intention: Compte tenu de la langue, de définir sa représentation de la grammaire, et de définir un interprète, l'interprète utilise le logo pour interpréter des phrases dans la langue.

Solution principale: Pour une grammaire fixe la construction d' une phrase pour expliquer interprète.

Quand utiliser: Si la fréquence d'un type particulier de problème est suffisamment élevé, il peut être utile chaque instance du problème est exprimé en tant que simples phrases dans la langue.Alors que vous pouvez construire un interprète, l'interprète de résoudre le problème en interprétant ces phrases.

Comment corriger: arbre de membre de la syntaxe, la définition du terminateur et nonterminal.

Le code clé: environnement de classe membre, certaines informations contenu global interprète extérieur, habituellement HashMap.

Exemples d'application: compilateur, évaluation de l' expression arithmétique.

Avantages: 1, une meilleure évolutivité, et flexibles.2, a ajouté une nouvelle façon d'interpréter l'expression. 3, facile à mettre en œuvre une grammaire simple.

Inconvénients: 1, peuvent tirer parti de la scène est relativement faible.2. Pour les complexes régles plus difficile à maintenir. 3 expliquer le mode fera la classe de se développer. 4 expliquer le mode en utilisant récursives appels de méthode.

Scénarios d' utilisation:1 peuvent être interprétés d' une phrase de langue doivent être représentés par un arbre de syntaxe abstraite. 2, certains des problèmes récurrents peut être un langage simple à exprimer. 3, une grammaire simple pour expliquer la scène.

Remarque: Vous pouvez utiliser relativement petite scène, JAVA si vous rencontrez peut expression4J place.

réalisation

Nous allons créer et mettre en œuvre une interface de classe d'entitéExpressioninterfaceExpression.Tel que défini dans le contexte deTerminalExpressioninterprète principal. D' autres classesOrExpression,AndExpression pour créer des expressions modulaires.

InterpreterPatternDemo,notre classe de démonstration utilise la classed'expressionpour créer des règles d'analyse et de présentation des expressions.

Etape 1

Créer une interface d'expression.

Expression.java

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

Etape 2

Créer classe d'entité implémente les interfaces 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);
   }
}

Etape 3

InterpreterPatternDemoutiliser la classed'expressionpour créer des règles et de les résoudre.

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

Etape 4

Vérifiez la sortie.

John est un homme? Vrai
Julie est une femme mariée? Vrai