Dans le développement de logiciels, nous rencontrons des problèmes se produisent à plusieurs reprises, et il y a une certaine similitude et de la régularité. Si elles sont regroupées dans une langue simple, ces questions seront des exemples de quelques phrases de la langue, de sorte que vous pouvez utiliser la « théorie compilateur » dans le mode interpréteur pour atteindre.
Bien que les exemples en utilisant un mode d'interprétation est pas beaucoup, mais pour répondre aux caractéristiques ci - dessus, et l' efficacité opérationnelle est pas très élevé exemple d'application, si le mode d'interprétation est mis en œuvre, l'effet est très bon, cet article présentera ses œuvres et utiliser.
La définition et les caractéristiques du modèle
Mode interprète défini (Interprète): analyser une définition d'objet de langage, et la définition de la grammaire de la langue, a re-concevoir un analyseur pour interpréter la langue de la phrase. En d' autres termes, un langage compilé pour analyser des exemples d'applications. Cette expression modèle de grammaire met en œuvre le processus d'interface, une explication spécifique du contexte d'interface.
Le concept de la grammaire et de la peine mentionnée ici dans la même théorie du compilateur pour décrire la même, la « grammaire » fait référence aux règles grammaticales de la langue, et « phrase » est l'objet d'éléments de langage. Par exemple, il y a beaucoup de phrase chinoise, « Je suis chinois » est une phrase, vous pouvez utiliser un arbre de syntaxe pour décrire visuellement les phrases dans la langue.
Interprète modèle est un type de classes de modèle, les principaux avantages suivants.
- Bonne extensibilité. L'utilisation des classes dans le mode interpréteur représenté règles de grammaire d'une langue et la grammaire peut être modifiée ou prolongée par des mécanismes d'héritage.
- Facile à mettre en œuvre. Chaque classe dans le nœud d'expression dans l'arbre de syntaxe sont similaires, il est relativement facile à réaliser sa grammaire.
Le principal inconvénient du mode expliqué ci-dessous.
- Plus le rendement. Interprète modèle couramment utilisé dans un grand nombre de cycles et des appels récursifs, quand expliquer des phrases plus complexes, sa vitesse est très lente, et le processus de débogage du code trop de problèmes.
- Classe causera un gonflement. Chaque mode règle interprète définir au moins une classe, lorsque la règle de grammaire contient un grand nombre, le nombre de classes augmentera fortement, et la gestion du système et la maintenance difficile.
- scène applicable est relativement faible. Dans le développement de logiciels, des exemples d'application doivent définir la grammaire de la langue est très faible, de sorte que ce mode est rarement utilisé pour.
Architecture et mise en œuvre Modèle
motif interprète couramment utilisé dans la compilation ou l'analyse des exemples de langage simple afin de maîtriser sa structure et la mise en œuvre, nous devons d'abord comprendre le principe de la traduction de « grammaire, arbre de syntaxe de la phrase » et d'autres concepts connexes.
1) grammaire
Les règles formelles de la grammaire est utilisée pour décrire la structure grammaticale de la langue. Pas de règles pas de normes, par exemple, certaines personnes pensent que les lignes directrices sont l'amour parfait « attraction mutuelle, la spécificité émotionnelle, aucune des deux parties amour expérimenté », bien que le dernier critère plus exigeant, mais rien d'autre, il y a des règles, de la langue, aussi, Que ce soit un langage machine ou langage naturel avec ses propres règles de grammaire. Par exemple, les Chinois dans la grammaire « phrase » suit.
〈句子〉::=〈主语〉〈谓语〉〈宾语〉
〈主语〉::=〈代词〉|〈名词〉
〈谓语〉::=〈动词〉
〈宾语〉::=〈代词〉|〈名词〉
〈代词〉你|我|他
〈名词〉7大学生I筱霞I英语
〈动词〉::=是|学习Note: la notation « :: = » signifie « est défini comme » moyen, avec le « < » et « > » enclose symbole non terminal, surround est pas de terminaison.
2) phrase
Phrase est l'unité de base de la langue, la langue est un ensemble d'éléments, qui se compose d'une terminaison peut être dérivée de « grammaire ». Par exemple, la grammaire ci-dessus peut être introduite, « I est un étudiant, » il est une phrase.
3) arbres de syntaxe
L'arbre de syntaxe est une structure arborescente d'une phrase, il représente le résultat de la dérivation de la peine, il est utile pour comprendre le niveau de la structure grammaticale des phrases. La figure 1 est « Je suis étudiant à l'université, » l'arbre de syntaxe.
1 phrase « Je suis étudiant à l'université, » l'arbre de syntaxe
Avec ces bases, maintenant introduire la structure du modèle d'interprétation est simple. Structure et mode d'interprétation modèle de combinaison similaire, mais il contient des éléments constitutifs que le motif de combinaison et une combinaison du modèle structurel est un modèle d'objet, est mode interprété type de modèle de classe.
1. Structure modèle
motif interprète se compose du rôle majeur suivant.
- expression abstraite (Abstract) Expression: Les rôles conventions d'interface définie d'interprétation expliquant le fonctionnement de l'interpréteur, comprenant une interprétation principale interpréter ().
- expression de Terminator (Expression Terminal) des rôles: sous-classes de l'expression abstraite est utilisé pour réaliser des opérations associées à des symboles terminaux de la grammaire, la grammaire de chaque symbole terminal a une extrémité d'expression particulière correspondant à celle-ci.
- expression des non-terminaux (non terminaux d'expression) des rôles: sous-classes de l'expression abstraite est utilisée pour mettre en œuvre l'opération de non-terminaux de la grammaire, la grammaire associée à chaque règle correspond à une expression non terminal.
- Environnement (Contexte) Rôles: comprend généralement des données ou des fonctions de l'interpréteur commun respectif nécessaire, généralement utilisé pour transmettre toutes les données partagées interprète, l'interprète peut obtenir ces dernières valeurs ici.
- Client (Client): La tâche principale de la phrase ou l'expression doit être analysée en utilisant la description de l'objet interprète de l'arbre de syntaxe abstraite, puis appelez l'interprète d'interprétation, bien sûr, vous pouvez également accéder indirectement par le rôle environnemental de l'interprète d'interprétation .
schéma de configuration de motif d'interprète représenté sur la figure 2.
2. Mode de réalisation
le mode d'interprétation clé est mise en œuvre des règles de grammaire définissent les classes de conception et de terminaison de classe non-terminal, la structure représentée sur la figure construit arbre syntaxe si nécessaire, la structure du code est suit comme:
//抽象表达式类
interface AbstractExpression
{
public Object interpret(String info); //解释方法
}
//终结符表达式类
class TerminalExpression implements AbstractExpression
{
public Object interpret(String info)
{
//对终结符表达式的处理
}
}
//非终结符表达式类
class NonterminalExpression implements AbstractExpression
{
private AbstractExpression exp1;
private AbstractExpression exp2;
public Object interpret(String info)
{
//非对终结符表达式的处理
}
}
//环境类
class Context
{
private AbstractExpression exp;
public Context()
{
//数据初始化
}
public void operation(String info)
{
//调用相关表达式类的解释方法
}
}
Mode d'exemples d'application
[Exemple 1] concevoir une carte de bus « Shao Unitoll » avec le programme d'interprétation du mode lecteur de carte.
Description: Si un lecteur de carte « Shao Yue Tong » peut déterminer l'identité des passagers d'autobus, si elle est « Shaoguan » ou « Canton » et « personnes âgées » « Les femmes », « enfant » peut être un tour gratuit, d' autres montent une boucle 2 yuans.
Analyse: Cet exemple de « mode d'interprétation » est une conception plus appropriée, la première conception qui suit les règles de grammaire.
<expression> ::= <city>的<person>
<city> ::= 韶关|广州
<person> ::= 老人|妇女|儿童Ensuite, selon les règles de conception du diagramme de classes de grammaire du programme de lecteur de carte de bus, procédez comme suit.
- Définir une expression abstraite (expression) interface, qui contient l'interprétation interprète (info String).
- L'expression définit une terminaison (Expression Terminal) classe, avec laquelle ensemble (Set) ou classe humaine pour maintenir la ville pour répondre aux conditions, et pour parvenir à une interface d'interprétation de l'expression abstraite interpréter (StringInfo), le caractère est déterminé à analyser si les chaînes sont terminateur ensemble.
- Terminator objet d'expression objet d'expression de terminaison du personnel et satisfaire aux conditions de la définition d'une classe d'expression non-terminale (AndExpressicm), qui est une sous-classe d'expression abstraite, qui comprend l'état de la ville, et d'obtenir l'interprétation (String info) méthode utilisée pour déterminer si la chaîne est analysée afin de répondre aux conditions des personnes remplissant la condition dans la ville.
- Enfin, la définition d'un environnement (contexte) classe, qui contient l'interpréteur de données nécessaires à l'initialisation complète de la terminaison de l'expression, et définit une méthode d'interprétation FREERIDE (info String) pour appeler l'objet d'expression de chaîne de caractères à analyser expliqué. La structure représentée sur la figure 3.
Code est la suivante:
package interpreterPattern;
import java.util.*;
/*文法规则
<expression> ::= <city>的<person>
<city> ::= 韶关|广州
<person> ::= 老人|妇女|儿童
*/
public class InterpreterPatternDemo
{
public static void main(String[] args)
{
Context bus=new Context();
bus.freeRide("韶关的老人");
bus.freeRide("韶关的年轻人");
bus.freeRide("广州的妇女");
bus.freeRide("广州的儿童");
bus.freeRide("山东的儿童");
}
}
//抽象表达式类
interface Expression
{
public boolean interpret(String info);
}
//终结符表达式类
class TerminalExpression implements Expression
{
private Set<String> set= new HashSet<String>();
public TerminalExpression(String[] data)
{
for(int i=0;i<data.length;i++)set.add(data[i]);
}
public boolean interpret(String info)
{
if(set.contains(info))
{
return true;
}
return false;
}
}
//非终结符表达式类
class AndExpression implements Expression
{
private Expression city=null;
private Expression person=null;
public AndExpression(Expression city,Expression person)
{
this.city=city;
this.person=person;
}
public boolean interpret(String info)
{
String s[]=info.split("的");
return city.interpret(s[0])&&person.interpret(s[1]);
}
}
//环境类
class Context
{
private String[] citys={"韶关","广州"};
private String[] persons={"老人","妇女","儿童"};
private Expression cityPerson;
public Context()
{
Expression city=new TerminalExpression(citys);
Expression person=new TerminalExpression(persons);
cityPerson=new AndExpression(city,person);
}
public void freeRide(String info)
{
boolean ok=cityPerson.interpret(info);
if(ok) System.out.println("您是"+info+"，您本次乘车免费！");
else System.out.println(info+"，您不是免费人员，本次乘车扣费2元！");
}
}Les résultats du Programme sont les suivants:
您是韶关的老人，您本次乘车免费！
韶关的年轻人，您不是免费人员，本次乘车扣费2元！
您是广州的妇女，您本次乘车免费！
您是广州的儿童，您本次乘车免费！
山东的儿童，您不是免费人员，本次乘车扣费2元！Application de modes de scène
La structure et les caractéristiques du mode de définition qui précède, l'analyse suivante de son scénario d'application.
- Lorsque la grammaire de la langue est simple et la mise en œuvre de l'efficacité n'est pas le principal problème.
- Lorsque le problème persiste, et peut utiliser un langage simple pour exprimer le temps.
- Quand une interprétation langue désirée, et des phrases dans la langue peuvent être exprimées sous forme d'un arbre de syntaxe abstraite, comme document XML explique.
Note: modèle d' interprétation utilisé dans le développement de logiciel lui- même est relativement faible, car elle conduira à l' efficacité, la performance et les problèmes d'entretien. Si vous appuyez sur l'interprétation des expressions en Java peut être utilisé comme la conception Expression4J ou Jep.
mode étendu
Dans le développement du projet, si vous voulez être une analyse de données d'expression et de calcul, ne prendra pas la conception du mode interpréteur, Java fournit la formule mathématique puissant suivant analyseur: Expression4J, (PSEM Math Expression chaîne Parser) et Jep, etc. ils peuvent expliquer une grammaire complexe, puissant, facile à utiliser.
Jep maintenant un exemple pour introduire l'utilisation de la boîte à outils. Jep est un court analyseur d'expression Java, que l' analyseur Java d'expression, qui est utilisé pour convertir une expression mathématique et calculer la bibliothèque Java. Par cette bibliothèque, l'utilisateur peut entrer une formule arbitraire comme une chaîne, puis de calculer rapidement le résultat. Et Jep prend en charge les variables définies par l' utilisateur, des constantes et des fonctions, qui comprend de nombreuses fonctions mathématiques courantes et constantes.
Télécharger Jep avant package compressé utilisation, déballées, sera Jep-xxxjar fichiers dans un répertoire de votre choix, sélectionnez l'onglet « Ajouter JAR externe (X) dans Eclipse » « de dialogue » Java Build Library Path « .. . », le package est ajouté après projet Jep d'utiliser l' un de la bibliothèque.
Ci - dessous l'intérêt calculate sur les dépôts à titre d'exemple à présenter. intérêt sur les dépôts est calculé: Taux Principal x Temps = x intérêt, le code correspondant est le suivant:
package interpreterPattern;
import com.singularsys.jep.*;
public class JepDemo
{
public static void main(String[] args) throws JepException
{
Jep jep=new Jep();
//定义要计算的数据表达式
String 存款利息="本金*利率*时间";
//给相关变量赋值
jep.addVariable("本金",10000);
jep.addVariable("利率",0.038);
jep.addVariable("时间",2);
jep.parse(存款利息); //解析表达式
Object accrual=jep.evaluate(); //计算
System.out.println("存款利息："+accrual);
}
}Les résultats du Programme sont les suivants:
存款利息：760.0
