In this post, We will talk and learn about the Interpreter Design Pattern in Java.
Key Points About Interpreter Design Pattern :
- Interpreter design pattern falls under behavioral design pattern.
- This pattern is mainly used to define a grammatical representation for a language and provides an interpreter to deal with this grammar.
- One of the best examples of an interpreter design pattern is a java compiler that interprets the java source code into byte code that is understandable by any JVM. Google Translator is also a good example of an interpreter pattern where the input can be in any language and we can get the output interpreted in another language.
Interpreter Design Pattern in JDK:
- java.util.Pattern and subclasses of java.text.Format
Now Let’s move towards the implementation of the Interpreter Design Pattern.
Below is the complete source code:
Expression.java
1 2 3 4 5 6 7 8 9 10 |
package com.kkjavatutorials.expression; import com.kkjavatutorials.engine.InterpreterEngine; /** * @author KK JavaTutorials * Contract to define language expression */ public interface Expression { public abstract int interpret(InterpreterEngine interpreterEngine); } |
AdditionExpression.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package com.kkjavatutorials.expression.impl; import com.kkjavatutorials.engine.InterpreterEngine; import com.kkjavatutorials.expression.Expression; /** * @author KK JavaTutorials * Concrete implementation of Expression * which perform addition for given * input expression */ public class AdditionExpression implements Expression { private String expression; public AdditionExpression(String expression) { this.expression = expression; } @Override public int interpret(InterpreterEngine interpreterEngine) { return interpreterEngine.addition(expression); } } |
SubtractionExpression.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package com.kkjavatutorials.expression.impl; import com.kkjavatutorials.engine.InterpreterEngine; import com.kkjavatutorials.expression.Expression; /** * @author KK JavaTutorials *Concrete implementation of Expression * which perform subtraction for given * input expression */ public class SubtractionExpression implements Expression { private String expression; public SubtractionExpression(String expression) { this.expression = expression; } @Override public int interpret(InterpreterEngine interpreterEngine) { return interpreterEngine.subtraction(expression); } } |
InterpreterEngine.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
package com.kkjavatutorials.engine; /** * @author KK JavaTutorials *This InterpreterEngine uses regular *expression to interpret input expression *to perform either addition or *substraction */ public class InterpreterEngine { //Perform Addition public int addition(String inputData) { String[] tokens = interpret(inputData); int number1 = Integer.parseInt(tokens[0]); int number2 = Integer.parseInt(tokens[1]); return number1 + number2; } //Perform Subtraction public int subtraction(String inputData) { String[] tokens = interpret(inputData); int number1 = Integer.parseInt(tokens[0]); int number2 = Integer.parseInt(tokens[1]); return number2 - number1; } private String[] interpret(String inputData) { String tempInputData = inputData.replaceAll("[^0-9]", " "); tempInputData = tempInputData.replaceAll("( )+", " ").trim(); String[] inputDatatokens = tempInputData.split(" "); return inputDatatokens; } } |
InterpreterClient.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
package com.kkjavatutorials.engine.client; import com.kkjavatutorials.engine.InterpreterEngine; import com.kkjavatutorials.expression.Expression; import com.kkjavatutorials.expression.impl.AdditionExpression; import com.kkjavatutorials.expression.impl.SubtractionExpression; /** * @author KK JavaTutorials *This InterpreterClient takes inputData and *perform either addition or substraction *that depends on inputData expression */ public class InterpreterClient { private InterpreterEngine interpreterEngine; public InterpreterClient(InterpreterEngine interpreterEngine) { this.interpreterEngine = interpreterEngine; } /** * Perform either addition or substraction * that depends on inputData expression * @param inputData input expression * @return added or subtracted value */ public int interpret(String inputData) { Expression expression = null; //Check if inputData has add word if (inputData.contains("add")) { expression = new AdditionExpression(inputData); } //Check if inputData has subtract word else if (inputData.contains("subtract")) { expression = new SubtractionExpression(inputData); }else { throw new RuntimeException(inputData+" is not valid expression!!"); } int result = expression.interpret(interpreterEngine); System.out.println(inputData); return result; } } |
InterpreterTest.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
package com.kkjavatutorials.client; import com.kkjavatutorials.engine.InterpreterEngine; import com.kkjavatutorials.engine.client.InterpreterClient; /** * @author KK JavaTutorials * Clinet program uses Interpreter * Design Pattern */ public class InterpreterTest { public static void main(String args[]) { //Create an Instance of InterpreterEngine InterpreterEngine interpreterEngine = new InterpreterEngine(); //Create an Instance of InterpreterClient InterpreterClient interpreterClient = new InterpreterClient(interpreterEngine); System.out.println("Addition of both Number is = " + interpreterClient.interpret("add 300 and 75")); System.out.println("---------------------------------------------------------------------------------"); System.out.println("Subtraction of number is = " + interpreterClient.interpret("subtract 40 from 100")); } } |
Output of this Program:
add 300 and 75
Addition of both Number is = 375
———————————————————————————
subtract 40 from 100
Subtraction of number is = 60
You May Also Like:
- Memento Design Pattern in Java
- Visitor Design Pattern in Java
- State Design Pattern in Java
- Command Design Pattern in Java
- Observer Design Pattern in Java
- Strategy Design Pattern in java
- Mediator Design Pattern in Java
- Chain of Responsibility Design Pattern in Java
- Template Design Pattern in Java
- Bridge Design Pattern in Java.
- Flyweight Design Pattern in Java
- Composite Design Pattern in Java
- Proxy Design Pattern in Java
- Facade Design Pattern in Java
- Decorator Design Pattern in Java
- Adapter Design Pattern in Java
- Builder Pattern in Java
- Abstract Factory Pattern in Java
- Factory design pattern in java
- Prototype Pattern in Java
- Singleton Design Pattern in java
That’s all about the Interpreter Design Pattern in Java.
If you have any feedback or suggestion please feel free to drop in below comment box.