第23章：インタプリタモード
まず、四則問題
四つの動作は、+ BCの値を計算する、インタプリタモードによって特定の要件を実装しました
最初のそのような+ B + C-D + Eとして表現の形式を入力し、文字の表現を繰り返すことができません
入力での、B、C、D、E値
最後に、結果が得られた：図
第二に、四則演算の解析の問題に対する従来の解決策
書き込み方法フォームの発現を受信し、その後、ユーザによって入力された値に従って解決、結果が得られました
分析：あなたは、このような* /などの新しい演算子を追加する場合（など、拡大に資するもので、ほかに混乱はなく、明確な十分の原因となりますプログラムの構造を解析するための方法を作るために。
解決策：使用を検討してインタプリタモードを、すなわち、：式- >通訳（複数存在することができます） - >結果
第三に、モードは、基本を説明して
基本的な導入
、パーサー解析木によって原理、字句解析字句単位によって形成された演算式、及び再ビルドこれらの語句単位をコンパイルする抽象構文解析ツリーを形成します。ここでは字句解析と構文解析器は、通訳として見ることができます
パターン（インタプリタパターン）インタプリタ：指定された言語（式）を指し、表現文法の定義および解釈を定義する使用、言語文を解釈するインタプリタを（式）
- シナリオ
- アプリケーションは、抽象構文木として表現されている言語で刑の執行を説明する必要があるかもしれ
- いくつかの定期的な問題は、簡単な言葉で表現することができます
- 構文必要なシーンを簡単に説明
このようなコンパイラのような例として、コンピューティング演算式、正規表現、ロボット工学
第四に、モードは、図クラスの原理を説明します
その（モード通訳の役割と責任） - クラス図の原理を説明するために、
コンテキスト：環境の役割は、世界的には、インタプリタを超えた情報が含まれています。
AbstractExpression：抽象的な表現、操作の抽象的解釈を宣言し、この方法は、すべてのノードで共有抽象構文木であります
TerminalExpression：ターミネータ式は動作を説明するターミネータに関連した文法で達成され、
NonTermialExpression：文法非終端記号の動作を説明する中で達成非ターミネーター式。
説明：コンテキストを入力し、彼はTerminalExpression情報は、クライアントによって入力することができます
第五に、4を達成するためのインタプリタモデル
- アプリケーション要件の例
解釈モードは、+ BCの値を計算するように、四則演算することにより達成されます
- アイデアと分析手法（図クラス）
- コードの実装
コンピューティング抽象クラス
package com.gjxaiou.interpreter;
import java.util.HashMap;
import java.util.Stack;
public class Calculator {
// 定义表达式
private Expression expression;
// 构造函数传参，并解析
public Calculator(String expStr) { // expStr = a+b
// 安排运算先后顺序
Stack<Expression> stack = new Stack<>();
// 表达式拆分成字符数组
char[] charArray = expStr.toCharArray();// [a, +, b]
Expression left = null;
Expression right = null;
//遍历我们的字符数组， 即遍历 [a, +, b]
//针对不同的情况，做处理
for (int i = 0; i < charArray.length; i++) {
switch (charArray[i]) {
case '+': //
left = stack.pop();// 从stack取出left => "a"
right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"
stack.push(new AddExpression(left, right));// 然后根据得到left 和 right 构建 AddExpresson加入stack
break;
case '-': //
left = stack.pop();
right = new VarExpression(String.valueOf(charArray[++i]));
stack.push(new SubExpression(left, right));
break;
default:
//如果是一个 Var 就创建要给 VarExpression 对象，并push到 stack
stack.push(new VarExpression(String.valueOf(charArray[i])));
break;
}
}
//当遍历完整个 charArray 数组后，stack 就得到最后Expression
this.expression = stack.pop();
}
public int run(HashMap<String, Integer> var) {
//最后将表达式a+b和 var = {a=10,b=20}
//然后传递给expression的interpreter进行解释执行
return this.expression.interpreter(var);
}
}式抽象クラス
package com.gjxaiou.interpreter;
import java.util.HashMap;
/**
* 抽象类表达式，通过HashMap 键值对, 可以获取到变量的值
*/
public abstract class Expression {
// a + b - c
// 解释公式和数值, key 就是公式(表达式) 参数[a,b,c], value就是就是具体值
// HashMap {a=10, b=20}
public abstract int interpreter(HashMap<String, Integer> var);
}
変数インタプリタ
package com.gjxaiou.interpreter;
import java.util.HashMap;
/**
* 变量的解释器
* @author Administrator
*
*/
public class VarExpression extends Expression {
private String key; // key=a,key=b,key=c
public VarExpression(String key) {
this.key = key;
}
// var 就是{a=10, b=20}
// interpreter 根据 变量名称，返回对应值
@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}
抽象演算符号通訳
package com.gjxaiou.interpreter;
import java.util.HashMap;
/**
* 抽象运算符号解析器 这里，每个运算符号，都只和自己左右两个数字有关系，
* 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
*
* @author Administrator
*
*/
public class SymbolExpression extends Expression {
protected Expression left;
protected Expression right;
public SymbolExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
//因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现
@Override
public int interpreter(HashMap<String, Integer> var) {
return 0;
}
}
特定のシンボルインタプリタ
package com.gjxaiou.interpreter;
import java.util.HashMap;
/**
* 加法解释器
* @author Administrator
*
*/
public class AddExpression extends SymbolExpression {
public AddExpression(Expression left, Expression right) {
super(left, right);
}
//处理相加
//var 仍然是 {a=10,b=20}..
//一会我们debug 源码,就ok
@Override
public int interpreter(HashMap<String, Integer> var) {
//super.left.interpreter(var) ： 返回 left 表达式对应的值 a = 10
//super.right.interpreter(var): 返回right 表达式对应值 b = 20
return super.left.interpreter(var) + super.right.interpreter(var);
}
}
//--------------------------------------------------------------------
package com.gjxaiou.interpreter;
import java.util.HashMap;
public class SubExpression extends SymbolExpression {
public SubExpression(Expression left, Expression right) {
super(left, right);
}
//求出left 和 right 表达式相减后的结果
@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
抽象クラスを使用します
package com.gjxaiou.interpreter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
public class ClientTest {
public static void main(String[] args) throws IOException {
String expStr = getExpStr(); // a+b
HashMap<String, Integer> var = getValue(expStr);// var {a=10, b=20}
Calculator calculator = new Calculator(expStr);
System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
}
// 获得表达式
public static String getExpStr() throws IOException {
System.out.print("请输入表达式：");
return (new BufferedReader(new InputStreamReader(System.in))).readLine();
}
// 获得值映射
public static HashMap<String, Integer> getValue(String expStr) throws IOException {
HashMap<String, Integer> map = new HashMap<>();
for (char ch : expStr.toCharArray()) {
if (ch != '+' && ch != '-') {
if (!map.containsKey(String.valueOf(ch))) {
System.out.print("请输入" + String.valueOf(ch) + "的值：");
String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}
}
シックスソースアプリケーションフレームワーク春の分析モードを説明します
春のフレームワークSpelExpressionParserは、モードを説明するために使用しました
+デバッグソースコード解析
- 説明
VIIノートや解釈のモードの詳細
言語の実装を説明する必要がある場合には、言語は抽象構文木などの文章で表現することができ、あなたはとてもプログラムが良いスケーラビリティを持っていることを、インタプリタモードの使用を検討することができます
シナリオ：コンパイラ、算術式の評価、正規表現、ロボット
インタプリタの使用がもたらす可能性があります：通訳パターンは、再帰呼び出しメソッドを使用してモードを説明するためのクラスが効率が低下することができる、非常に複雑なデバッグになります腫れ引き起こす可能性があります。