Este artigo descreve a implementação do Java para definir uma função de linguagem simples com base no padrão de intérprete. Compartilhe -o para sua referência, como segue:
Uma definição de padrão
Padrão de intérprete: é dar uma representação gramatical de um idioma e definir um intérprete para interpretar frases no idioma. O padrão de intérprete descreve como interpretar essas declarações usando o design de padrões após uma gramática simples.
Exemplos do segundo modo
1 Análise de padrão
Nós projetamos uma linguagem para ilustrar esse padrão
(1) O idioma é sensível ao minúsculo (2) O idioma começa com o programa e termina com a extremidade (3) imprimir significa imprimir uma linha e quebrá -la (4) usar para… de… a… final significa loop de loop
O conteúdo do idioma de exemplo é o seguinte:
Program Println Start ... para I de 90 a 100 Println i End Println End ... Fim
O significado desta frase é: Primeiro imprima a quebra da linha com "Start ..." e depois percorrer a quebra da linha com "90", "91", ... "100" e finalmente imprima a quebra da linha com "End ...".
2 Este idioma explica a estrutura da árvore
3 Diagrama de atividades do intérprete da linguagem
4 exemplos de código
4.1 Crie um ambiente de contexto - contexto
pacote com.demo.interpreter.Context; importar java.util.hashmap; importar java.util.iterator; importar java.util.map; importar java.util.stringTokenizer;/** ** ** ** * * * * * * * @author */público // o comando atual private string currentToken; // usado para armazenar alterações dinamicamente do conteúdo do conteúdo privado mapa final <string, object> map = new hashmap <string, object> (); / * * } / *** Parsing text* / public string next () {if (this.stringTokenizer.hasMORETOKENS ()) {currentToken = this.stringTokenizer.NextToken (); } else {currentToken = null; } retornar o CurrentToken; } / ** * Determine se o comando está correto * * @param comando * @return * / public boolean EqualSwithCommand (String Command) {if (command == null ||! Command.equals (this.currentToken)) {return false; } retornar true; } / ** * Obtenha o conteúdo do comando atual * * @return * / public string getCurrentToken () {return this.currentToken; } / ** * Obtenha o conteúdo do nó * * @return * / public string getTokencOntent (text string) {string str = text; if (str! = null) {// Substitua a alteração dinamicamente de conteúdo no mapa e retorne o iterador <String> // Substitua a alteração dinamicamente de conteúdo no mapa e retorne o iterador <String> iterator = this.map.keyset (). iterator (); while (iterator.hasnext ()) {string key = iterator.Next (); Objeto obj = map.get (chave); str = str.Replaceall (chave, obj.toString ()); }} retornar str; } public void put (chave de string, valor do objeto) {this.map.put (chave, valor); } public void clear (chave de string) {this.map.remove (key); }}4.2 Interface de expressão - IEXPressions
pacote com.demo.interpreter.express; importar com.demo.interpreter.context.context;/** * * interface de expressão * * @author * */interface pública iexpressions {/** * parsing * * @param context */public void parse (contexto contexto); / ** * Método de execução * * @param context */ public void Interpret ();}4.3 Expressão Principal - Programaxpressão
pacote com.demo.interpreter.express; importar com.demo.interpreter.context.context;/** * Expressão do programa * * @author * */public class Programxpression implementa iexpressions {// ambiente de contexto de contexto final privado; // comando atual private final static string command = "Program"; // armazenar a próxima expressão Referência de Expressões Privadas IEXPressions; / ** * Construtor passa o conteúdo a ser analisado para * * @param text */ public ProgramMexpression (text String) {this.Context = new Context (texto); this.parse (this.Context); } @Override public void parse (contexto de contexto) {// Obtenha o primeiro nó de comando this.Context.Next (); } / *** Método de explicação de implementação* / @Override public void Interpret () {// Determine se ele começa com o programa if (! This.Context.equalSwithCommand (command)) {System.out.println ("o '" + comando + "' é exceto para start!"); } else {// inicie this.Context.Next () com o programa; this.expressões = new Latexpression (); this.expressions.parse (this.Context); // A expressão do Latexpression inicia o analisando isso.expressões.interpret (); }}}4.4 Lista Expression - Listexpressão
pacote com.demo.interpreter.express; importar java.util.ArrayList; importar java.util.iterator; importar com.demo.interpreter.context.Context;/** * List Expression * * @author * */public class Latexpressões iExpressões {contexto privado; contexto; Private Final ArrayList <Iexpressions> list = new ArrayList <Iexpressions> (); / ** * O construtor passa o contexto a ser analisado para * * @param context */ public void parse (contexto de contexto) {this.Context = context; // Na expressão da análise da Latexpression, loop para interpretar cada palavra na instrução até que a expressão ou exceção do Terminator sai while (true) {if (this.Context.getCurrentToken () == NULL) {// Obtenha o nó atual. Se nulo, significa que a expressão final está ausente do sistema.out.println ("Erro: a expansão ausente 'end'!"); quebrar; } else if (this.context.equalSwithCommand ("end")) {this.Context.Next (); // Parsing normalmente termina; } else {// crie expressão de comando iexpressions expressões = new commandExperSion (this.Context); // add to list.add (expressões); }}} / *** Implemente o método de explicação* / @Override public void Interpret () {// Loop a explicação de cada expressão na lista da lista para executar o iterador <Iexpressions> iterator = list.iterator (); while (iterator.hasnext ()) {(iterator.Next ()). Interpret (); }}}4.5 Expressão de comando - CommandExpersion
pacote com.demo.interpreter.express; importar com.demo.interpreter.context.context;/** * Expressão de comando * * @author * */public class CommandExperSion implementa iexpressões {contexto final privado contexto; Expressões privadas de IEXPressions; / ** * O método de construção passa o contexto a ser analisado para * * @param context */ public CommandExperSsion (contexto de contexto) {this.Context = context; this.parse (this.Context); } public void parse (contexto de contexto) {// julgando a categoria de comando atual, distingue apenas e o comando original se (this.Context.EqualSwithCommand ("para")) {// Crie para expressão para a análise de expressões = nova portexpressão (this.Context); } else {// Crie expressão de comando original para conteúdo expressões de análise = new primitiveExpression (this.Context); }} / *** Parsing conteúdo* / @Override public void Interpret () {// Parsing conteúdo this.expressions.interpret (); }}4.6 Expressão de loop - Forexpressão
pacote com.demo.interpreter.express; importar com.demo.interpreter.context.context;/** * para expressão * * @author * */classe pública Implementos de porexpressão iexpressões {contexto final privado contexto; // Armazene a variável atual do valor do índice de índice private String; // armazenar a posição inicial do loop privado int start_index; // armazenar a posição final do loop privado int end_index; Expressões privadas de IEXPressions; / ** * O construtor passa o contexto a ser analisado para * * @param context */ public Forexpression (contexto de contexto) {this.Context = context; this.parse (this.Context); } / *** Parsing Expression* / @Override public void parse (contexto de contexto) {// primeiro obtenha o nó atual this.Context.Next (); while (true) {// julgue o nó if (this.Context.equalSwithCommand ("de")) {// Defina o índice de inicialização string de conteúdo nextStr = this.Context.Next (); tente {this.start_index = Integer.parseint (nextStr); } catch (Exceção e) {System.out .println ("Erro: Após 'de' Expressa existir Erro! Verifique o formato da expressão está correto!"); quebrar; } // Obtenha o próximo nó this.Context.Next (); } else if (this.Context.equalSwithCommand ("to")) {// Defina o índice final String nextStr = this.Context.Next (); tente {this.end_index = Integer.parseint (nextStr); } Catch (Exceção e) {System.out .println ("Erro: Após 'para' Expressão Existe Erro! Verifique se o formato da expressão está correto!"); } this.Context.Next (); quebrar; } else {// Defina o conteúdo da variável de índice atual if (this.variable == null) {this.variable = this.Context.getCurrentToken (); } // Obtenha o próximo nó this.Context.Next (); }} // Crie uma expressão de lista this.expressions = new Latexpression (); this.expressions.parse (this.Context); } / *** Implemente o método de explicação* / @Override public void Interpret () {// Crie uma expressão de comando para (int x = this.start_index; x <= this.end_index; x ++) {// Defina o conteúdo variável this.Context. (""+this.Variable, x); // execute o método de explicação this.expressions.interpret (); } // Remova o conteúdo variável temporário usado this.Context.clear ("" + this.Variable); }}4.7 Expressões básicas - PrimitiveExpression
pacote com.demo.interpreter.express; importar com.demo.interpreter.context.context;/** * A expressão mais básica * * @author * */classe pública PrimitiveExpression implementa iexpressões {contexto privado contexto; // NODE NOME PRIVADO String TokenName; // Texto de texto Private String Texto; / ** * O construtor passa o contexto a ser analisado para * * @param context */ público primitivo Expressão (contexto de contexto) {this.parse (context); } @Override public void parse (contexto de contexto) {this.Context = context; this.tokenname = this.Context.getCurrentToken (); this.Context.Next (); if ("println" .equals (this.tokenname)) {this.text = this.Context.getCurrentToken (); this.Context.Next (); }} / *** Método de explicação de implementação* / @Override public void Interpret () {// primeiro obtenha o conteúdo atual do nó if ("println" .equals (tokenname)) {// obtenha informações de conteúdo // print content system.out.println (this.Context.getToContent (this.text); }}}4.8 Deixe o intérprete de idioma começar a funcionar - cliente
pacote com.demo.interpreter; importar com.demo.interpreter.express.iexpressions; importar com.demo.interpreter.express.programxpression;/** * Aplicativo principal * * @author * */public class client {/** * @param args */public static void main (string [] A 100 println i end println end ... end "; System.out.println ("str:" + str); // Crie expressão do programa IEXPressions Expressions = new ProgramMexpression (STR); // Explique a execução de expressões.interpret (); }}5 resultados em execução
STR: Program Println Start ... para I de 90 a 100 Println i End Println End ... Fim
Começar...
90
91
92
93
94
95
96
97
98
99
100
fim...
Três princípios de design
1 Princípio de "Close Open"
2 O princípio da mudança fechada
Quatro ocasiões de uso
(1) Um tipo específico de problema ocorre em alta frequência, e as regras de negócios mudam com frequência e situações semelhantes ocorrem repetidamente.
(2) As regras de negócios não são muito complicadas e pesadas, e é mais fácil abstrair regras gramaticais.
(3) A eficiência não é um fator principal considerado nos sistemas de software.
Diagrama de classes estática no modo de cinco intérpretes
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"
Espero que este artigo seja útil para a programação Java de todos.