Interpreter-Muster

Das Interpreter-Muster bietet eine Möglichkeit, die Grammatik oder Ausdrücke einer Sprache auszuwerten, und es gehört zu den Verhaltensmustern.

Das Interpreter-Muster definiert für eine gegebene Sprache eine Darstellung ihrer Grammatik und definiert einen Interpreter, der diese Darstellung verwendet, um Sätze in der Sprache zu interpretieren.

Dieses Muster wird beim SQL-Parsing, in Symbolverarbeitungs-Engines usw. verwendet.

Einführung

Absicht

Definieren Sie eine grammatische Darstellung für eine Sprache und erstellen Sie einen Interpreter, der Sätze in der Sprache interpretieren kann.

Wesentliche gelöste Probleme

  • Das Interpreter-Muster wird verwendet, um einen Interpreter zu erstellen, der Sätze einer bestimmten Sprache oder Grammatik interpretieren kann.

Anwendungsfall

  • Wenn eine bestimmte Art von Problem häufig auftritt und Instanzen dieser Probleme durch eine einfache Sprache ausgedrückt werden können.

Implementierungsansatz

  • Grammatik definieren: Definiert die terminalen und nichtterminalen Symbole der Sprache.
  • Syntaxbaum aufbauen: Erstellt die entsprechende Syntaxbaumstruktur basierend auf den Sätzen der Sprache.
  • Kontextklasse erstellen: Enthält die globalen Informationen, die während des Interpretationsprozesses benötigt werden, normalerweise eine HashMap.

Schlüsselcode

  • Terminale und nichtterminale Symbole: Definieren die Grammatikstruktur der Sprache.
  • Umgebungsklasse: Speichert die externen Umgebungsinformationen, die während des Interpretationsprozesses benötigt werden.

Anwendungsbeispiel

  • Compiler: Das Interpreter-Muster kann im Compiler-Design verwendet werden, um Quellcode in Zielcode zu interpretieren.
  • Regulärer Ausdruck: Das Interpreter-Muster kann verwendet werden, um reguläre Ausdrücke zu parsen und auszuführen.
  • SQL-Parsing: Das Interpreter-Muster kann verwendet werden, um SQL-Anweisungen zu parsen und auszuführen.

Vorteile

  • Gute Erweiterbarkeit: Einfach, neue Wege zur Interpretation von Ausdrücken hinzuzufügen.
  • Flexibilität: Die Grammatik kann nach Bedarf leicht erweitert oder geändert werden.
  • Einfache Grammatiken sind leicht zu implementieren: Für einfache Sprachen ist die Implementierung relativ einfach.

Nachteile

  1. Begrenzte Einsatzszenarien: Nur für einfache Grammatiken geeignet, die für die Interpretation geeignet sind.
  2. Schwer zu warten: Bei komplexen Grammatiken werden Wartung und Erweiterung schwierig.
  3. Klassenexplosion: Es können viele Klassen entstehen, wobei eine Klasse jeder Grammatikregel entspricht.
  4. Rekursiver Aufruf: Das Interpreter-Muster verwendet normalerweise rekursive Aufrufe, die schwer zu verstehen und nachzuvollziehen sein können.

Verwendungshinweise

  • Erwägen Sie die Verwendung des Interpreter-Musters, wenn Sie Sätze in einer Sprache interpretieren und ausführen müssen.
  • Stellen Sie sicher, dass die Grammatik einfach ist, um das System nicht übermäßig komplex zu machen.

Hinweise

  • Das Interpreter-Muster ist in Java möglicherweise nicht die erste Wahl. Wenn geeignete Szenarien auftreten, ziehen Sie stattdessen Bibliotheken wie expression4J in Betracht.

Struktur

Das Interpreter-Muster umfasst die folgenden Hauptrollen:

  • Abstrakter Ausdruck: Definiert die abstrakte Schnittstelle des Interpreters, deklariert die Methoden für Interpretationsoperationen, normalerweise eine abstrakte Klasse oder Schnittstelle.

  • Terminaler Ausdruck: Eine terminale Ausdrucksklasse, die die abstrakte Ausdrucksschnittstelle implementiert, verwendet wird, um Terminals in der Sprache darzustellen (wie Variablen, Konstanten usw.), und die entsprechenden Interpretationsoperationen implementiert.

  • Nichtterminaler Ausdruck: Eine nichtterminale Ausdrucksklasse, die das abstrakte Ausdrucks-Interface implementiert, verwendet, um Nichtterminale in der Sprache (wie Sätze, Ausdrücke usw.) darzustellen, und die entsprechenden Interpretationsoperationen implementiert.

  • Kontext: Enthält einige globale Informationen außerhalb des Interpreters, die dem Interpreter während des Interpretationsprozesses bereitgestellt werden, normalerweise verwendet, um Variablenwerte zu speichern, den Interpreter-Zustand zu sichern usw.

  • Client: Erstellt und konfiguriert spezifische Interpreter-Objekte und übergibt den zu interpretierenden Ausdruck an den Interpreter zur Interpretation.

Implementierung

Wir werden ein InterfaceExpressionerstellen und eine konkrete Klasse des InterfaceExpressionimplementieren. Definiert den Hauptinterpreter im Kontext.TerminalExpressionKlasse. Andere KlassenOrExpression、AndExpressionzur Erstellung zusammengesetzter Ausdrücke.

InterpreterPatternDemo, unsere Demo-Klasse verwendetExpressionKlassenerstellungsregeln und das Parsen von Demonstrationsausdrücken.

解释器模式的 UML 图

Schritt 1

Erstellen Sie ein Expression-Interface.

Expression.java

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

Schritt 2

Erstellen Sie Entity-Klassen, die das obige Interface 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

InterpreterPatternDemoVerwendungExpressionKlassen zum Erstellen von Regeln und zu deren Parsen.

InterpreterPatternDemo.java

public class InterpreterPatternDemo { //Regel: Robert und John sind männlich public static Expression getMaleExpression(){ Expression robert = new TerminalExpression("Robert"); Expression john = new TerminalExpression("John"); return new OrExpression(robert, john); } //Regel: Julie ist eine verheiratete Frau 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("Ist John männlich? " + isMale.interpret("John")); System.out.println("Julie ist eine verheiratete Frau? " + isMarriedWoman.interpret("Verheiratete Julie")); } }

Schritt 4

Führen Sie das Programm aus, Ausgabeergebnisse:

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