gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

#107 Interpreter example JavaDoc

Browse Source
This commit is contained in:
Ilkka Seppala 2015-08-18 23:10:08 +03:00
parent 0d8b3c9935
commit 5831d3239d
7 changed files with 220 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
interpreter/src/main/java/com/iluwatar/interpreter/App.java
View File

@ -1,68 +1,72 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
import java.util.Stack; import java.util.Stack;
/** /**
* *
* Interpreter pattern breaks sentences into expressions (Expression) that can * Interpreter pattern breaks sentences into expressions ({@link Expression}) that can
* be evaluated and as a whole form the result. * be evaluated and as a whole form the result.
* *
*/ */
public class App { public class App {
/** /**
* *
* Expressions can be evaluated using prefix, infix or postfix notations * Program entry point.
* This sample uses postfix, where operator comes after the operands * <p>
* * Expressions can be evaluated using prefix, infix or postfix notations
*/ * This sample uses postfix, where operator comes after the operands
public static void main(String[] args) { *
String tokenString = "4 3 2 - 1 + *"; * @param args command line args
Stack<Expression> stack = new Stack<>(); *
*/
String[] tokenList = tokenString.split(" "); public static void main(String[] args) {
for (String s : tokenList) { String tokenString = "4 3 2 - 1 + *";
if (isOperator(s)) { Stack<Expression> stack = new Stack<>();
Expression rightExpression = stack.pop();
Expression leftExpression = stack.pop(); String[] tokenList = tokenString.split(" ");
System.out for (String s : tokenList) {
.println(String.format( if (isOperator(s)) {
"popped from stack left: %d right: %d", Expression rightExpression = stack.pop();
leftExpression.interpret(), Expression leftExpression = stack.pop();
rightExpression.interpret())); System.out
Expression operator = getOperatorInstance(s, leftExpression, .println(String.format(
rightExpression); "popped from stack left: %d right: %d",
System.out.println(String.format("operator: %s", operator)); leftExpression.interpret(),
int result = operator.interpret(); rightExpression.interpret()));
NumberExpression resultExpression = new NumberExpression(result); Expression operator = getOperatorInstance(s, leftExpression,
stack.push(resultExpression); rightExpression);
System.out.println(String.format("push result to stack: %d", System.out.println(String.format("operator: %s", operator));
resultExpression.interpret())); int result = operator.interpret();
} else { NumberExpression resultExpression = new NumberExpression(result);
Expression i = new NumberExpression(s); stack.push(resultExpression);
stack.push(i); System.out.println(String.format("push result to stack: %d",
System.out.println(String.format("push to stack: %d", resultExpression.interpret()));
i.interpret())); } else {
} Expression i = new NumberExpression(s);
} stack.push(i);
System.out System.out.println(String.format("push to stack: %d",
.println(String.format("result: %d", stack.pop().interpret())); i.interpret()));
} }
}
public static boolean isOperator(String s) { System.out
return s.equals("+") || s.equals("-") || s.equals("*"); .println(String.format("result: %d", stack.pop().interpret()));
} }
public static Expression getOperatorInstance(String s, Expression left, public static boolean isOperator(String s) {
Expression right) { return s.equals("+") || s.equals("-") || s.equals("*");
switch (s) { }
case "+":
return new PlusExpression(left, right); public static Expression getOperatorInstance(String s, Expression left,
case "-": Expression right) {
return new MinusExpression(left, right); switch (s) {
case "*": case "+":
return new MultiplyExpression(left, right); return new PlusExpression(left, right);
} case "-":
return null; return new MinusExpression(left, right);
} case "*":
} return new MultiplyExpression(left, right);
}
return null;
}
}

23
interpreter/src/main/java/com/iluwatar/interpreter/Expression.java
View File

@ -1,9 +1,14 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
public abstract class Expression { /**
*
public abstract int interpret(); * Expression
*
@Override */
public abstract String toString(); public abstract class Expression {
}
public abstract int interpret();
@Override
public abstract String toString();
}

51
interpreter/src/main/java/com/iluwatar/interpreter/MinusExpression.java
View File

@ -1,23 +1,28 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
public class MinusExpression extends Expression { /**
*
private Expression leftExpression; * MinusExpression
private Expression rightExpression; *
*/
public MinusExpression(Expression leftExpression, Expression rightExpression) { public class MinusExpression extends Expression {
this.leftExpression = leftExpression;
this.rightExpression = rightExpression; private Expression leftExpression;
} private Expression rightExpression;
@Override public MinusExpression(Expression leftExpression, Expression rightExpression) {
public int interpret() { this.leftExpression = leftExpression;
return leftExpression.interpret() - rightExpression.interpret(); this.rightExpression = rightExpression;
} }
@Override @Override
public String toString() { public int interpret() {
return "-"; return leftExpression.interpret() - rightExpression.interpret();
} }
} @Override
public String toString() {
return "-";
}
}

53
interpreter/src/main/java/com/iluwatar/interpreter/MultiplyExpression.java
View File

@ -1,24 +1,29 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
public class MultiplyExpression extends Expression { /**
*
private Expression leftExpression; * MultiplyExpression
private Expression rightExpression; *
*/
public MultiplyExpression(Expression leftExpression, public class MultiplyExpression extends Expression {
Expression rightExpression) {
this.leftExpression = leftExpression; private Expression leftExpression;
this.rightExpression = rightExpression; private Expression rightExpression;
}
public MultiplyExpression(Expression leftExpression,
@Override Expression rightExpression) {
public int interpret() { this.leftExpression = leftExpression;
return leftExpression.interpret() * rightExpression.interpret(); this.rightExpression = rightExpression;
} }
@Override @Override
public String toString() { public int interpret() {
return "*"; return leftExpression.interpret() * rightExpression.interpret();
} }
} @Override
public String toString() {
return "*";
}
}

55
interpreter/src/main/java/com/iluwatar/interpreter/NumberExpression.java
View File

@ -1,25 +1,30 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
public class NumberExpression extends Expression { /**
*
private int number; * NumberExpression
*
public NumberExpression(int number) { */
this.number = number; public class NumberExpression extends Expression {
}
private int number;
public NumberExpression(String s) {
this.number = Integer.parseInt(s); public NumberExpression(int number) {
} this.number = number;
}
@Override
public int interpret() { public NumberExpression(String s) {
return number; this.number = Integer.parseInt(s);
} }
@Override @Override
public String toString() { public int interpret() {
return "number"; return number;
} }
} @Override
public String toString() {
return "number";
}
}

51
interpreter/src/main/java/com/iluwatar/interpreter/PlusExpression.java
View File

@ -1,23 +1,28 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
public class PlusExpression extends Expression { /**
*
private Expression leftExpression; * PlusExpression
private Expression rightExpression; *
*/
public PlusExpression(Expression leftExpression, Expression rightExpression) { public class PlusExpression extends Expression {
this.leftExpression = leftExpression;
this.rightExpression = rightExpression; private Expression leftExpression;
} private Expression rightExpression;
@Override public PlusExpression(Expression leftExpression, Expression rightExpression) {
public int interpret() { this.leftExpression = leftExpression;
return leftExpression.interpret() + rightExpression.interpret(); this.rightExpression = rightExpression;
} }
@Override @Override
public String toString() { public int interpret() {
return "+"; return leftExpression.interpret() + rightExpression.interpret();
} }
} @Override
public String toString() {
return "+";
}
}

33
interpreter/src/test/java/com/iluwatar/interpreter/AppTest.java
View File

@ -1,14 +1,19 @@
package com.iluwatar.interpreter; package com.iluwatar.interpreter;
import org.junit.Test; import org.junit.Test;
import com.iluwatar.interpreter.App; import com.iluwatar.interpreter.App;
public class AppTest { /**
*
@Test * Application test
public void test() { *
String[] args = {}; */
App.main(args); public class AppTest {
}
} @Test
public void test() {
String[] args = {};
App.main(args);
}
}