Dieser Artikel beschreibt die Implementierung von Java, um eine einfache Sprachfunktion basierend auf dem Interpreter -Muster zu definieren. Teilen Sie es für Ihre Referenz wie folgt weiter:
Eine Musterdefinition
Interpreter -Muster: Es soll eine grammatikalische Darstellung einer Sprache angeben und einen Dolmetscher definieren, um Sätze in der Sprache zu interpretieren. Das Interpreter -Muster beschreibt, wie diese Aussagen mit dem Musterdesign nach einer einfachen Grammatik interpretiert werden.
Beispiele für den zweiten Modus
1 Musteranalyse
Wir haben eine Sprache entworfen, um dieses Muster selbst zu veranschaulichen
(1) Die Sprache ist fälschlichempfindlich (2) Die Sprache beginnt mit dem Programm und endet mit End (3) Println bedeutet, eine Linie zu drucken und sie zu brechen (4) Verwenden Sie für… von… bis… Ende bedeutet Schleife
Der Beispielsprachinhalt lautet wie folgt:
Programm println start ... für i von 90 bis 100 println i ende println End ... Ende
Die Bedeutung dieses Satzes lautet: Drucken Sie zuerst den Zeilenpausen mit "Start ...", dann durch den Linienbruch mit "90", "91", ... "100" und drucken Sie schließlich die Zeilenpause mit "Ende ...".
2 Diese Sprache erklärt die Baumstruktur
3 Aktivitätsdiagramm des Sprachdolmetschers
4 Code Beispiele
4.1 Erstellen Sie eine Kontextumgebung - Kontext
Paket com.demo.InterPreter.Context; import Java.util.hashMap; Import Java.util.iterator; import Java.util.map; Import Java.util.stringTokenizer;/** * Kontextumgebung * * @author */Public Class Context {// Die Textinhalte, die private endgültige private endgültige private endgültige private endgültig sind, um private endgültige private endgültige private endgültige private endgültige zu sein. // der aktuelle Befehl private Zeichenfolge aktuelles String; // Wird verwendet, um dynamisch Änderungen von Informationen inhalts Inhalt Private Final Map <String, Object> map = New HashMap <String, Object> (); / ** * Konstruktor legt Parsing -Inhalt fest * * @param text */ public context (String text) {// Verwenden Sie Leerzeichen, um den zu analysierenden Text zu trennen. } / *** analysieren text* / public String next () {if (this.stringTokenizer.hasmoretokens ()) {currentToken = this.stringTokenizer.NextToken (); } else {currentToken = null; } return CurrentToken; } / ** * Bestimmen Sie, ob der Befehl korrekt ist } Return true; } / ** * den aktuellen Befehlsinhalt abrufen * * @return * / public String getCurrentToken () {return this.currentToken; } / ** * Erhalten Sie den Inhalt des Knotens * * @return * / public String getTokenContent (String text) {String str = text; if (str! = null) {// Ersetzen Sie den dynamisch ändernden Inhalt in der Karte und return iterator <string> // Ersetzen Sie den dynamisch ändernden Inhalt in der Karte und return iterator <string> iterator = this.map.keyset (). iterator (); while (iterator.hasnext ()) {String key = iterator.next (); Objekt obj = map.get (Schlüssel); str = str.replaceall (Schlüssel, Obj.ToString ()); }} return str; } public void put (String -Schlüssel, Objektwert) {this.map.put (Schlüssel, Wert); } public void clear (String -Schlüssel) {this.map.remove (Schlüssel); }}4.2 Expression Schnittstelle - Iexpressions
Paket com.demo.interpreter.express; importieren com.demo.interpreter.context.context;/** * * Ausdrucksschnittstelle * * @author * */public interface iexpressions {/** * Parsen * * @param Context */Public void PARSE (Kontextkontext); / ** * Ausführungsmethode * * @param Context */ public void interpretation ();}4.3 Hauptausdruck - Programexpression
Paket com.demo.interpreter.express; importieren com.demo.interpreter.context.context;/** * Programmausdruck * * @Author * */Public Class Programexpression implementiert IExpressions {// Context Environment Private Final Context Context; // Aktueller Befehl private endgültige statische String -Befehl = "Programm"; // Die nächste Ausdrucksreferenz private iExpressionsausdrücke speichern; / ** * Konstruktor übergibt den Inhalt, der in * * @param text analysiert werden soll this.Parse (this.context); } @Override public void Parse (Kontextkontext) {// Erhalten Sie den ersten Befehlsknoten this.context.next (); } / *** Implementierung Erläuterung } else {// starten Sie this.context.next () mit dem Programm; this.expressions = new listExpression (); this.expressions.parse (this.context); // ListExpression Expression beginnt mit der Analyse this.expressions.interpret (); }}}4.4 LIST -Ausdruck - ListExpression
Paket com.demo.InterPreter.express; import Java.util.ArrayList; importieren java.util.iterator; com.demo.Interpeter.Context.Context;/** * List Ausdruck * * @Author * * */öffentliche Klassenliste implements iExpressions {private context context; private Final ArrayList <Iexpression> list = new ArrayList <Iexpressions> (); / ** * Konstruktor übergibt den Kontext, der in * * @param Context */ public void Parse (Kontextkontext) {this.context = context; // In der ListExpression -Analyse -Expression interpretieren Sie jedes Wort in der Anweisung, bis der Ausdruck oder die Ausnahme des Terminators beendet wird, wobei (true) {if (this.context.getCurrentToken () == null) {// den aktuellen Knoten erhalten. Wenn NULL, bedeutet dies, dass der Endausdruck system.out.println fehlt ("Fehler: Die Expersion fehlt 'Ende'!"); brechen; } else if (this.context.equalsWithCommand ("End")) {this.context.next (); // Das Parsen normalerweise beendet brechen; } else {// Befehlsausdruck erstellen iExpressions expressions = new candapeexpersion (this.context); // zu list.add (Ausdrücke) hinzufügen; }}} / *** Erläuterungsmethode implementieren* / @Override public void interpretation () {// Schleifen Sie die Erläuterung jedes Ausdrucks in der Liste in der Liste, um Iterator <Iexpressions> iterator = list.iterator () auszuführen; while (iterator.hasnext ()) {(iterator.next ()). interpretieren (); }}}4.5 Befehlsausdruck - Commandexpersion
Paket com.demo.interpreter.express; importieren com.demo.interpreter.context.context;/** * Befehlsausdruck * * @Author * */public class CommandExpersion implementiert IExpressions {private endgültige Kontextkontext; private Ausdrücke von Iexpressions; / ** * Konstruktmethode übergibt den Kontext, der in * * @param Context */ public CommandExperSsion (Kontextkontext) {this.context = context; this.Parse (this.context); } public void parse (Kontextkontext) {// Die aktuelle Befehlskategorie beurteilen, nur für und den ursprünglichen Befehl unterscheiden if (this.context.equalswithCommand ("for")) {// Erstellen Sie für den Ausdruck für Parsing -Ausdrücke = new Forexpression (this.context); } else {// Erstellen Sie den ursprünglichen Befehlsausdruck für Inhaltsanalyse -Ausdrücke = new PrimitiveExpression (this.context); }} / *** Inhalt analysieren* / @Override public void interpretation () {// Inhalt analysieren. }}4.6 Schleifenexpression - Forexpression
Paket com.demo.interpreter.express; importieren com.demo.interpreter.context.context;/** * für den Ausdruck * * @Author * */öffentliche Klasse Forexpression implementiert IExpressions {private endgültige Kontextkontext; // Speichern Sie den aktuellen Indexschlüsselwert Private String Variable; // Speichern Sie die Startposition des Loop Private int start_index; // Speichern Sie die Endposition der Schleife private int end_index; private Ausdrücke von Iexpressions; / ** * Konstruktor übergibt den Kontext, der in * * @param Context */ public Forexpression (Kontextkontext) {this.context = context; this.Parse (this.context); } / *** Ausdruck analysieren* / @Override public void parse (context context) {// Erinnern Sie den aktuellen Knoten this.context.next (); while (true) {// beurteilen den Knoten if (this.context.equalswithCommand ("from")) {// Setzen Sie den Start -Index -Inhaltsstring von Nextstr = this.context.next (); try {this.start_index = integer.parseInt (nextstr); } catch (Ausnahme E) {System.out .println ("Fehler: After 'From' Expression existieren Fehler! Bitte überprüfen Sie das Format des Ausdrucks ist korrekt!"); brechen; } // den nächsten Knoten this.context.next () erhalten; } else if (this.context.equalsWithCommand ("to")) {// Setzen Sie den Endindex -Inhaltsstring von Nextstr = this.context.next (); try {this.end_index = integer.parseInt (nextstr); } catch (Ausnahme e) {System.out .println ("Fehler: After 'to' Expression existieren Fehler! Bitte überprüfen Sie das Format des Ausdrucks ist korrekt!"); } this.context.next (); brechen; } else {// Setzen Sie den Inhalt der aktuellen Indexvariablen if (this.variable == null) {this.variable = this.context.getCurrentToken (); } // den nächsten Knoten this.context.next () erhalten; }} // Erstellen Sie einen List -Ausdruck this.expression = new listExpression (); this.expressions.parse (this.context); } / *** Implementieren Sie die Erläuterungsmethode* / @Override public void interpretation () {// Erstellen Sie einen Befehlsausdruck für (int x = this.start_index; x <= this.end_index; x ++) {// den variablen Inhalt this.context.put ("+this.variable, x); // Die Erklärungsmethode this.expressions.interpret () ausführen; } // den verwendeten temporären variablen Inhalt entfernen.Context.clear ("" + this.Variable); }}4.7 Grundausdrücke - primitive EXpression
Paket com.demo.interpreter.express; importieren com.demo.interpreter.context.context;/** * Der grundlegendste Ausdruck * * @author * */public class PrimitiveExpression implementiert IExpressions {private context context; // Knotenname privater String -Tokenname; // Textinhalte privater String -Text; / ** * Der Konstruktor übergibt den Kontext, der in * * @param Context */ public primitiveExpression (Kontextkontext) {this.Parse (Kontext) analysiert wird. } @Override public void parse (Kontextkontext) {this.context = context; this.tokenName = this.context.getCurrentToken (); this.context.next (); if ("println" .equals (this.tokenName)) {this.text = this.context.getCurrentToken (); this.context.next (); }} / *** Implementierung Erläuterungsmethode* / @Override public void interpretation () {// Erstigen Sie den aktuellen Knoteninhalt, wenn ("println" .equals (toKenname)) {// Inhaltsinformationen erhalten // content system.out.println (this.context.getToKEntent (this.text)); }}}4.8 Lassen Sie den Sprachdolmetscher beginnen - Client
package com.demo.interpreter;import com.demo.interpreter.express.IExpressions;import com.demo.interpreter.express.ProgramExpression;/** * Main application* * @author * */public class Client { /** * @param args */ public static void main(String[] args) { // myida language statement String str = "PROGRAM PRINTLN start... FOR i FROM 90 bis 100 println i ende println End ... Ende "; System.out.println ("Str:" + str); // Programmexpression erstellen iexpressions expressions = new programexpression (str); // Erklären Sie die Ausführung von Ausdrücken.interpret (); }}5 Laufen Ergebnisse
STR: Programm Println Start ... für i von 90 bis 100 println i ende println End ... Ende
Start...
90
91
92
93
94
95
96
97
98
99
100
Ende...
Drei Entwurfsprinzipien
1 "Open-Close" -Prinzip
2 Das Prinzip der geschlossenen Veränderung
Vier Nutzungsanlässe
(1) Eine bestimmte Art von Problem tritt bei hoher Häufigkeit auf, und die Geschäftsregeln ändern sich häufig und ähnliche Situationen treten wiederholt auf.
(2) Geschäftsregeln sind nicht zu kompliziert und umständlich, und es ist einfacher, grammatikalische Regeln abstrahieren zu können.
(3) Effizienz ist kein Hauptfaktor in Softwaresystemen.
Das statische Klassendiagramm des Interpretentum -Modus
For more Java-related content, readers who are interested in this site can view the topics: "Introduction and Advanced Tutorial on Java Object-Oriented Programming", "Tutorial on Java Data Structure and Algorithm", "Summary of Java Operation DOM Node Skills", "Summary of Java File and Directory Operation Skills" and "Summary of Java Cache Operation Skills"
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.