Comment implémenter le mode interprète pour l'analyse de langages et d'expressions personnalisés en Java

Introduction

Java Interpreter pattern (Interpreter pattern) est un modèle de conception comportemental qui définit la représentation syntaxique d'un langage et définit un interprète pour interpréter la syntaxe.#🎜 🎜#

Le cœur de ce modèle est l'interpréteur (Interpreter), qui définit une interface d'expression et une classe d'implémentation d'expression spécifique. L'interface d'expression définit la méthode d'interprétation et la classe d'implémentation d'expression spécifique implémente Cette méthode d'interprétation est utilisée pour expliquer la grammaire. 🎜#

Le mode interpréteur Java contient les 4 rôles suivants :

Expression abstraite (Abstract Expression) : définit une interface que l'interpréteur doit implémenter, comprenant généralement une méthode d'interprétation (interprète) pour interpréter les expressions.
Terminal Expression ) : Implémente la méthode d'interprétation de l'interface d'expression abstraite, utilisée pour interpréter les symboles terminaux du langage, tels que les variables. , constantes, etc.
Expression non terminale (Expression non terminale) : implémente la méthode d'interprétation de l'interface d'expression abstraite, qui est généralement composée de plusieurs expressions terminales et est utilisé pour interpréter les symboles non terminaux du langage, tels que les opérateurs arithmétiques, les opérateurs logiques, etc. #🎜🎜 #

• Environnement (Contexte) : Contient des informations contextuelles du langage qui doivent être interprétés, comme des variables, des constantes, etc. En mode interprète, l'objet environnement est généralement passé en paramètre à l'objet interprète

• Implementation.

Ce qui suit est un exemple simple pour expliquer les expressions d'addition et de soustraction

Expression abstraite

public interface Expression {
    /**
     * 解释表达式
     *
     * @return
     */
    int interpreter();
}

terminal expression

public class NumberExpression implements Expression{
    private int num;
    public NumberExpression(int num) {
        this.num = num;
    }
    /**
     * 解释表达式
     *
     * @return
     */
    @Override
    public int interpreter() {
        return num;
    }
}

#🎜 🎜#expression non-terminale

public class AddExpression implements Expression {
    /**
     * 左表达式
     */
    private Expression leftExpression;
    /**
     * 右表达式
     */
    private Expression rightExpression;
    public AddExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
    /**
     * 解释表达式
     *
     * @return
     */
    @Override
    public int interpreter() {
        return leftExpression.interpreter() + rightExpression.interpreter();
    }
}
public class SubtractExpression implements Expression {
    /**
     * 左表达式
     */
    private Expression leftExpression;
    /**
     * 右表达式
     */
    private Expression rightExpression;
    public SubtractExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
    /**
     * 解释表达式
     *
     * @return
     */
    @Override
    public int interpreter() {
        return leftExpression.interpreter() - rightExpression.interpreter();
    }
}

test

public class Demo {
    public static void main(String[] args) {
        // 创建一个复杂表达式,用于计算5+3-2+1的结果
        Expression expression = new AddExpression(
                new SubtractExpression(
                        new AddExpression(
                                new NumberExpression(5), new NumberExpression(3)),
                        new NumberExpression(2)),
                new NumberExpression(1));
        // 使用解释器模式来解释表达式,并输出计算结果
        System.out.println(expression.interpreter());
    }
}

#🎜 🎜#

Dans l'exemple ci-dessus, nous avons défini une interface d'expression Expression (résumé expression) et deux classes d'implémentation d'expression spécifiques AddExpression (expression non terminale) et SubtractExpression (expression non terminale) (Expression terminale). Dans les classes AddExpression et SubtractExpression, nous avons implémenté respectivement la méthode d'interprétation pour interpréter les expressions d'addition et de soustraction, et défini une NumberExpression (expression terminale) qui a implémenté la méthode d'interprétation d'Expression pour interpréter les nombres Expression. Dans l'exemple ci-dessus, l'objet d'environnement n'est pas explicitement défini, mais l'environnement est simulé en créant et en combinant des objets d'expression. 🎜#

Forte extensibilité : le mode interpréteur peut implémenter de nouveaux comportements en étendant les expressions et les règles de grammaire dans le langage. Par exemple : de nouvelles expressions terminales et expressions non terminales peuvent être ajoutées. Des expressions terminales pour implémenter des règles de grammaire plus complexes.# 🎜🎜#

Facile à mettre en œuvre : Le mode interpréteur est relativement simple à mettre en œuvre, et ne nécessite que d'implémenter des expressions abstraites et des classes d'expressions concrètes. C'est tout.

Facile à changer les règles de grammaire : Puisque le mode interprète représente les règles de grammaire sous forme d'objets, vous pouvez changer les règles de grammaire en modifiant la façon dont les objets interprètes sont combinés

#🎜. 🎜#

Inconvénients
Nécessite un grand nombre de classes : La mise en œuvre d'un langage complexe peut nécessiter de définir un grand nombre de classes, cela augmentera la complexité et la maintenance coût du code. Bon, surtout pour les développeurs qui ne connaissent pas le modèle et lorsque le langage exécute des règles de grammaire spécifiques, comme des expressions mathématiques, des expressions régulières, etc. 🎜🎜#Quand il est nécessaire d'étendre les règles de grammaire du langage, comme l'ajout de nouveaux symboles ou commandes d'opérations.
Quand il est nécessaire d'encapsuler et d'exécuter des complexes logique d'interprétation dans le code, telle que les compilateurs, les analyseurs, etc.
Note

Essayez de ne pas utiliser le mode interprète dans les modules importants, sinon la maintenance sera un gros problème. Vous pouvez utiliser shell, JRuby, Groovy, etc. dans le projet. Le langage de script remplace le mode interpréteur pour combler les lacunes du langage compilé Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!