Patrón Intérprete

El patrón intérprete (Interpreter Pattern) proporciona una manera de evaluar la gramática o las expresiones de un lenguaje; pertenece a los patrones de comportamiento.

El patrón intérprete, dado un lenguaje, define una representación de su gramática y define un intérprete que utiliza dicha representación para interpretar las oraciones del lenguaje.

Este patrón se utiliza en el análisis de SQL, motores de procesamiento de símbolos, etc.

Introducción

Intención

Definir una representación gramatical de un lenguaje y crear un intérprete que pueda interpretar las oraciones de dicho lenguaje.

Problema principal que resuelve

El patrón intérprete se utiliza para construir un intérprete capaz de interpretar oraciones de un lenguaje o gramática específicos.

Escenarios de uso

Cuando un tipo específico de problema ocurre con frecuencia y sus instancias pueden expresarse mediante un lenguaje simple.

Forma de implementación

Definir la gramática: identificar los símbolos terminales y no terminales del lenguaje.
Construir el árbol sintáctico: construir la estructura de árbol sintáctico correspondiente según las oraciones del lenguaje.
Crear la clase de contexto: contiene la información global necesaria durante el proceso de interpretación; normalmente es un HashMap.

Código clave

Símbolos terminales y no terminales: definen la estructura gramatical del lenguaje.
Clase de contexto: almacena la información del entorno externo necesaria durante la interpretación.

Ejemplos de aplicación

Compiladores: el patrón intérprete puede utilizarse en el diseño de compiladores para interpretar código fuente en código objeto.
Expresiones regulares: el patrón intérprete puede utilizarse para analizar y ejecutar expresiones regulares.
Análisis de SQL: el patrón intérprete puede utilizarse para analizar y ejecutar sentencias SQL.

Ventajas

Buena escalabilidad: es fácil añadir nuevas formas de interpretar expresiones.
Flexibilidad: la gramática puede ampliarse o modificarse fácilmente según sea necesario.
Fácil de implementar gramáticas simples: para lenguajes simples, la implementación es relativamente fácil.

Desventajas

Escenarios de uso limitados: solo es adecuado para gramáticas simples que se presten a la interpretación.
Mantenimiento difícil: para gramáticas complejas, el mantenimiento y la ampliación resultan difíciles.
Inflación de clases: puede generar muchas clases, una por cada regla gramatical.
Llamadas recursivas: el patrón intérprete suele utilizar llamadas recursivas, lo que puede dificultar la comprensión y el seguimiento.

Sugerencias de uso

Cuando necesite interpretar y ejecutar oraciones de un lenguaje, considere utilizar el patrón intérprete.
Asegúrese de que la gramática sea simple para evitar que el sistema se vuelva demasiado complejo.

Precauciones

El patrón intérprete puede no ser la primera opción en Java; si se encuentra con un escenario aplicable, puede considerar utilizar bibliotecas como expression4J en su lugar.

Estructura

El patrón intérprete incluye los siguientes roles principales:

Expresión abstracta (Abstract Expression): define la interfaz abstracta del intérprete y declara los métodos de la operación de interpretación; normalmente es una clase abstracta o interfaz.
Expresión terminal (Terminal Expression): la clase de expresión terminal implementa la interfaz de expresión abstracta para representar los símbolos terminales del lenguaje (como variables, constantes, etc.) y realiza la operación de interpretación correspondiente.
Expresión no terminal (Non-terminal Expression): la clase de expresión no terminal implementa la interfaz de expresión abstracta para representar los símbolos no terminales del lenguaje (como oraciones, expresiones, etc.) y realiza la operación de interpretación correspondiente.
Contexto (Context): contiene información global externa al intérprete que se proporciona a este durante el proceso de interpretación; normalmente se utiliza para almacenar los valores de las variables, conservar el estado del intérprete, etc.
Cliente (Client): crea y configura los objetos intérprete concretos, y pasa las expresiones que deben interpretarse al intérprete.

Implementación

Vamos a crear una interfazExpressiony las clases concretas que implementanExpressionla interfaz. Definir la clase que actúa como intérprete principal en el contextoTerminalExpressionClase. Las otras clasesOrExpression、AndExpressionse utilizan para crear expresiones combinadas.

InterpreterPatternDemo, nuestra clase de demostración utilizaExpressionlas clases para crear reglas y demostrar el análisis de expresiones.

Paso 1

Crear una interfaz de expresión.

Expression.java

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

Paso 2

Crear las clases concretas que implementan la interfaz anterior.

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

Paso 3

InterpreterPatternDemoUtilizarExpressionlas clases para crear reglas y analizarlas.

InterpreterPatternDemo.java

public class InterpreterPatternDemo { //Regla: Robert y John son hombres public static Expression getMaleExpression(){ Expression robert = new TerminalExpression("Robert"); Expression john = new TerminalExpression("John"); return new OrExpression(robert, john); } //Regla: Julie es una mujer casada 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")); } }

Paso 4

Ejecutar el programa y mostrar el resultado:

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

Otras extensiones

Patrones de diseñoOtro