下载 23种设计模式源码 ：http://download.csdn.net/download/knight_black_bob/8936043
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
创建型模式，共五种：
工厂方法模式 抽象工厂模式 单例模式 建造者模式 原型模式
结构型模式，共七种：
适配器模式 装饰器模式 代理模式 外观模式 桥接模式 组合模式 享元模式
行为型模式，共十一种：
策略模式 模板方法模式 观察者模式 迭代子模式 责任链模式 命令模式
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
好多的 加法运算 ，没有发现 加括号的 的加减乘除的 解释器，参考了 别人的 算法，写了 这个 ，只能说别人的算法好，，，，
算法地址：http://blog.sina.com.cn/s/blog_6759f4610100j2qt.html
package 设计模式.解释器模式;
import java.util.HashMap;
import java.util.Map;
public class Context {
private final Map<String, Integer> valueMap = new HashMap<String, Integer>();
public void addValue(final String key, final int value) {
valueMap.put(key, Integer.valueOf(value));
}
public int getValue(final String key) {
return valueMap.get(key).intValue();
}
}
package 设计模式.解释器模式;
public abstract class AbstractExpression {
public abstract int interpreter(Context context);
}
package 设计模式.解释器模式;
public class TerminalExpression extends AbstractExpression {
private final int i;
public TerminalExpression(final int i) {
this.i = i;
}
@Override
public int interpreter(final Context context) {
return this.i;
}
}
package 设计模式.解释器模式;
public class AddNonterminalExpression extends AbstractExpression {
private final AbstractExpression left;
private final AbstractExpression right;
public AddNonterminalExpression(final AbstractExpression left,
final AbstractExpression right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter(final Context context) {
return this.left.interpreter(context) + this.right.interpreter(context);
}
}
package 设计模式.解释器模式;
public class SubtractNonterminalExpression extends AbstractExpression {
private final AbstractExpression left;
private final AbstractExpression right;
public SubtractNonterminalExpression(final AbstractExpression left,
final AbstractExpression right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter(final Context context) {
return this.left.interpreter(context) - this.right.interpreter(context);
}
}
package 设计模式.解释器模式;
public class MultiplyNonterminalExpression extends AbstractExpression {
private final AbstractExpression left;
private final AbstractExpression right;
public MultiplyNonterminalExpression(final AbstractExpression left,
final AbstractExpression right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter(final Context context) {
return this.left.interpreter(context) * this.right.interpreter(context);
}
}
package 设计模式.解释器模式;
public class DivisionNonterminalExpression extends AbstractExpression {
private final AbstractExpression left;
private final AbstractExpression right;
public DivisionNonterminalExpression(final AbstractExpression left,
final AbstractExpression right) {
this.left = left;
this.right = right;
}
@Override
public int interpreter(final Context context) {
final int value = this.right.interpreter(context);
if (value != 0) {
return this.left.interpreter(context) / value;
}
return -1111;
}
}
package 设计模式.解释器模式;
//解释器模式定义语言的文法，并且建立一个解释器来解释该语言中的句子。它属于类的行为模式。这里的语言意思是使用规定格式和语法的代码。
//应用环境：
//如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。
//这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。而且当文法简单、效率不是关键问题的时候效果最好。
public class InterpreterDemo {
// 40~47 ( ) * + , - . / 0~9 是 48~57 a~z 是 97~122 A~Z 是 65~90 61 =
// ( a+ b * ( a + b ) * a ) * b + a
// [1, +, 2, *, (, 3, +, 4, *, 5, ), *, 1, #]
class NumQueue {
char num[];
int head, rear;
NumQueue() {
num = new char[1];
head = -1;
rear = -1;
}
public boolean isEmpty() {
if (head == rear)
return true;
else
return false;
}
public void inQueue(char ch) {
num[++rear] = ch;
}
public void init() {
head = -1;
rear = -1;
for (int i = 0; i < 1; i++)
num[i] = '\0';
}
public String getNumber() {
String str = new String(num);
return str;
}
}
class StackAbstractExpression {
AbstractExpression data[];
int top;
int base;
StackAbstractExpression() {
data = new AbstractExpression[15];
top = -1;
base = -1;
}
public AbstractExpression getTop() {
return data[top];
}
public void push(AbstractExpression ae) {
data[++top] = ae;
}
public AbstractExpression pop() {
return data[top--];
}
public boolean isEmpty() {
if (top == base)
return true;
else
return false;
}
public void init() {
top = -1;
base = -1;
}
}
class StackOper {
char data[];
int top;
int base;
StackOper() {
data = new char[20];
top = -1;
base = -1;
}
public char getTop() {
return data[top];
}
public void init() {
top = -1;
base = -1;
}
public void push(char ch) {
data[++top] = ch;
}
public char pop() {
return data[top--];
}
public boolean isEmpty() {
if (top == base)
return true;
else
return false;
}
}
static StackAbstractExpression stackData;
static StackOper stackOper;
static NumQueue queue;
static boolean rs, divErr = false;
public static void doHandler(String exp, Context context){
queue = new InterpreterDemo().new NumQueue();
stackData = new InterpreterDemo().new StackAbstractExpression();
stackOper = new InterpreterDemo().new StackOper();
exp = exp.replaceAll(" ","");
exp+= "#";
stackOper.init();
stackData.init();
stackOper.push('#');
String dou = "";
int ps = 0, pc = 0;
System.out.println(" exp: "+exp);
char ch[] = exp.toCharArray();
char op;
int i = 0;
op = ch[i];
while (op != '#' || stackOper.getTop() != '#') {
if ((op > 96 && op < 123) ) {
queue.inQueue(op);
i++;
op = ch[i];
} else {
if (!queue.isEmpty()) {
dou = queue.getNumber();
//System.out.println ("stackData.push (" + dou + ") ");
stackData.push(new TerminalExpression(context.getValue(dou)));
queue.init();
}
ps = getSPri(stackOper.getTop());
pc = getCPri(op);
if (stackOper.getTop() == '(' && op == '#'
|| stackOper.getTop() == ')' && op == '('
|| stackOper.getTop() == '#' && op == ')') {
rs = true;
}
if (ps < pc) {
//System.out.println (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc +" "+ "stackOper.push " + op + " ");
stackOper.push(op);
i++;
op = ch[i];
}
if (ps == pc) {
char c = stackOper.pop();
//System.out.println (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc + "stackOper.pop " + c + " ");
op = ch[++i];
}
if (ps > pc) {
char theta = stackOper.pop();
AbstractExpression b = stackData.pop();
AbstractExpression a = stackData.pop();
stackData.push(operate(a, b, theta));
//System.out.println (" 操作符在栈内的优先级 " + ps +" 操作符进栈的优先级优先级 "+ pc +" stackData.push " +operate(a, b, theta)+ " ");
}
}
}
double res = stackData.getTop().interpreter(context);
System.out.println(res);
rs = true;
}
public static AbstractExpression operate(AbstractExpression a, AbstractExpression b, char ch) {
AbstractExpression res =null;
switch (ch) {
case '+':
res = new AddNonterminalExpression( a, b);
break;
case '-':
res = new SubtractNonterminalExpression( a, b);
break;
case '*':
res = new MultiplyNonterminalExpression( a, b);
break;
case '/':
res = new DivisionNonterminalExpression( a, b);
break;
default:
break;
}
return res;
}
// 操作符在栈内的优先级
public static int getSPri(char op) {
int pr = 0;
switch (op) {
case ')':
pr = 6;
break;
case '*':
pr = 5;
break;
case '/':
pr = 5;
break;
case '+':
pr = 3;
break;
case '-':
pr = 3;
break;
case '(':
pr = 1;
break;
case '#':
pr = 0;
break;
}
return pr;
}
// 操作符进栈的优先级优先级
public static int getCPri(char op) {
int pr = 0;
switch (op) {
case ')':
pr = 1;
break;
case '*':
pr = 4;
break;
case '/':
pr = 4;
break;
case '+':
pr = 2;
break;
case '-':
pr = 2;
break;
case '(':
pr = 6;
break;
case '#':
pr = 0;
break;
}
return pr;
}
public static void main(String[] args) {
final Context context = new Context();
context.addValue("a", 1);
context.addValue("b", 2);
doHandler("(a+b*(a+b)*a)*b+a",context);
}
}
捐助开发者
在兴趣的驱动下,写一个免费的东西，有欣喜，也还有汗水，希望你喜欢我的作品，同时也能支持一下。 当然，有钱捧个钱场（右上角的爱心标志，支持支付宝和PayPal捐助），没钱捧个人场，谢谢各位。
谢谢您的赞助，我会做的更好！
相关推荐
**设计模式之解释器模式(Interpreter Pattern)** 解释器模式是一种行为设计模式，它提供了一种方式来表示语言的语法，并实现一个解释器用于解析这种语法的语句。这种模式通常用于小型、特定领域的语言（DSL）实现，...
【Android编程设计模式之解释器模式详解】 解释器模式（Interpreter Pattern）是设计模式中的一种行为模式，主要用于解析特定语言或表达式。在Android开发中，尽管不常见，但当需要自定义简单的语言或者表达式解释...
解释器模式是一种行为设计模式，它允许我们定义一个语言的语法，并提供一个解释器来解析该语言中的句子。在Java中实现解释器模式，我们可以创建一个抽象表达式接口，然后为每种特定的语法结构创建一个具体表达式类。...
**解释器模式（Interpreter）**是一种行为设计模式，它允许我们定义一种语言并为其创建一个解释器。在软件工程中，这种模式常用于处理简单的语言或表达式，例如配置文件、计算公式或者简单的脚本语言。通过使用解释...
解释器模式（Interpreter Pattern）是一种行为型设计模式，用于为特定语言的句法定义一个解释器。它通过定义一个语言的文法表示以及解释器的实现来解析和执行表达式。这种模式通常用于设计语言、脚本或规则引擎。 ...
解释器模式是一种行为型设计模式，主要用于处理语言的文法规则、算术规则等问题。它通过定义语言的文法，并根据该文法来解释句子，使得我们可以用统一的方式处理各种语言结构。本文将通过具体的例子——加减运算来...
解释器模式是一种行为设计模式，它提供了一种方式来表示一种特定语言的语法，并创建一个解释器来解析这种语言中的句子。在计算机科学中，解释器模式常用于实现简单的语言或表达式计算。这种模式的主要组件包括抽象...
本文实例讲述了Python设计模式之解释器模式原理与用法。分享给大家供大家参考，具体如下： 解释器模式(Interpreter Pattern):给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释...
解释器模式是一种设计模式，它允许我们为特定的语言或表达式定义一个解析规则。在软件工程中，这种模式常用于构建简单的语言解释器或者执行基于某种规则的逻辑。本讲将深入探讨解释器模式的原理、结构以及在实际开发...
Java 设计模式之解释器模式 解释器模式是一个行为类模式，它定义了一个语言的文法表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。该模式的结构主要包括抽象解释器、终结符表达式、非终结符...
- 在计算机编程中，解释器模式是一种指定如何评估一种语言中的句子的设计模式。基本思想是为专门计算机语言中的每个符号（终结符或非终结符）都有一个类。该语言句子的语法树是组合模式的一个实例，并用于为客户端...
解释器模式是一种设计模式，属于类行为模式，它允许我们为特定语言定义语法，并提供一个解释器来解析这种语言中的句子。在Java中，解释器模式通常用于处理简单的语言或表达式，例如布尔表达式计算。 在解释器模式中...
解释器模式（Interpreter模式）是设计模式的一种，主要用于在程序设计中实现对特定语言或表达式的解释。在Java中，这种模式的应用可以帮助我们构建一种语言的解析器，从而理解和执行该语言的句子。以下是对解释器...
3. 行为型模式：如策略模式、模板方法模式、观察者模式、命令模式、迭代器模式、责任链模式、备忘录模式、状态模式、解释器模式和访问者模式。这些模式主要处理对象之间的通信和行为，让代码更易于理解和扩展。 在...