Contenido de este artículo
1. Introducción al modo de intérprete
El patrón de intérprete proporciona una forma de evaluar la gramática o la expresión del idioma y pertenece al patrón de comportamiento. Este patrón implementa una interfaz de expresión que interpreta un contexto específico. Este modo se utiliza en análisis de SQL, motores de procesamiento de símbolos, etc.
1. Introducción al modo de intérprete
Intención: Dado un idioma, defina su representación gramatical y defina un intérprete que use el identificador para interpretar oraciones en el idioma.
La solución principal: construir un intérprete para algunas gramáticas fijas para explicar oraciones.
Cuándo usarlo: si un tipo particular de problema ocurre con suficiente frecuencia, entonces puede valer la pena expresar cada instancia del problema como una oración en un lenguaje sencillo. De esta forma, se puede construir un intérprete que resuelva el problema interpretando estas oraciones.
Cómo resolverlo: construir un árbol gramatical, definir terminal y no terminal.
Código clave: cree la clase de entorno, que contiene información global fuera del intérprete, generalmente HashMap.
Ejemplos de aplicación: compilador, cálculo de expresiones aritméticas.
Ventajas: 1. Buena escalabilidad y flexibilidad. 2. Se ha agregado una nueva forma de interpretar expresiones. 3. Fácil de implementar gramática simple.
Desventajas: 1. Pocos escenarios disponibles. 2. Es difícil mantener una gramática complicada. 3. El modo de intérprete provocará una expansión de la clase. 4. El modo de intérprete utiliza un método de llamada recursiva.
Escenarios de uso: 1. Una oración en un lenguaje que necesita ser interpretada y ejecutada se puede representar como un árbol de sintaxis abstracto. 2. Algunos problemas recurrentes se pueden expresar en un lenguaje sencillo. 3. Un escenario en el que es necesario explicar una gramática simple.
Nota: Hay relativamente pocos escenarios disponibles. Si se encuentran en JAVA, se puede usar expression4J en su lugar.
Dos, implementación de código
Los ejemplos de implementación de código de todos los patrones de diseño se pueden ver en Code Cloud. Si está interesado, puede verificarlo. Dirección de Code Cloud: https://gitee.com/no8g/java-design-patterns
Crearemos una expresión de interfaz y una clase de entidad que implementa la interfaz de expresión. Defina la clase TerminalExpression como el intérprete principal en el contexto. Las otras clases OrExpression y AndExpression se utilizan para crear expresiones combinadas.
InterpreterPatternClient, nuestra clase de demostración usa la clase Expression para crear reglas y demostrar el análisis de expresiones.
paso uno
/**
* <p>Expression 此接口用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月22日 16:24</p>
* <p>@remark：创建一个表达式接口</p>
*/
public interface Expression {
/**
* 表达式接口
*
* @param context 文法
* @return 是否为true
*/
public boolean interpret(String context);
}Segundo paso
package com.iot.practice.designpattern.interpreter;
/**
* <p>TerminalExpression 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月22日 16:26</p>
* <p>@remark：创建实现了上述接口的实体类</p>
*/
public class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) {
this.data = data;
}
@Override
public boolean interpret(String context) {
return context.contains(this.data);
}
}package com.iot.practice.designpattern.interpreter;
/**
* <p>OrExpression 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月22日 16:29</p>
* <p>@remark：</p>
*/
public class OrExpression implements Expression {
private Expression expression1 = null;
private Expression expression2 = null;
public OrExpression (Expression expression1, Expression expression2) {
this.expression1 = expression1;
this.expression2 = expression2;
}
@Override
public boolean interpret(String context) {
return this.expression1.interpret(context) || this.expression2.interpret(context);
}
}
package com.iot.practice.designpattern.interpreter;
/**
* <p>AndExpression 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月22日 16:31</p>
* <p>@remark：</p>
*/
public class AndExpression implements Expression {
private Expression expression1 = null;
private Expression expression2 = null;
public AndExpression(Expression expression1, Expression expression2) {
this.expression1 = expression1;
this.expression2 = expression2;
}
@Override
public boolean interpret(String context) {
return this.expression1.interpret(context) && this.expression2.interpret(context);
}
}
Paso tres
package com.iot.practice.designpattern.interpreter;
/**
* <p>InterpreterPatternClient 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月22日 16:33</p>
* <p>@remark：InterpreterPatternClient 使用 Expression 类来创建规则，并解析它们。</p>
*/
public class InterpreterPatternClient {
/**
* 规则：Robert 和 John 是男性
*
* @return 表达式接口
*/
public static Expression getMaleExpression() {
Expression robert = new TerminalExpression("Robert");
Expression john = new TerminalExpression("John");
return new OrExpression(robert, john);
}
/**
* 规则：Julie 是一个已婚的女性
*
* @return 表达式接口
*/
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("Robert is male ? The answer is " + isMale.interpret("Robert"));
System.out.println("Julie is a married woman ? The answer is " + isMarriedWoman.interpret("Julie Married"));
}
}
Paso cuatro
Ejecute el programa y muestre el resultado:
¿Robert es hombre? La respuesta es verdadera
¿Julie es una mujer casada? La respuesta es verdadera
¡fin!