Java Behavioral Design Patterns – Interpreter Design Pattern
The Interpreter design pattern is one of the behavioral design patterns that give specification about how to evaluate sentences in a language.
Java compiler or for that matter compiler for any language is the perfect example of this pattern. The user inputs are converted into a language that is understandable by underlying JVM. In this pattern, the problem is generally solved by:
- Defining grammar or rules for language
- The rules are interpreted and processed upon.
<Here are ALL other Java Design Patterns, explained in detail with examples>
Interpreter Design Pattern by Example
When implementing interpreter design pattern, we need to create an interpreter engine. This engine will do the interpretation for us. We also design different expression implementations. These concrete implementations will utilize the functionalities provided by interpreter engine.
Of course, we will also write a simple client that will take user input (in our case sample string of instructions) and process it with customized interpreter engine.
For our demo purpose, we will define an interpreter engine that will understand basic addition and subtraction instructions. The instructions will be in the form of humanly understandable syntax.
E.g. add 12 and 13 or subtract 76 from 621
Let’s define our simple Expression interface.
|
1 2 3 |
public interface Expression { public int interpret(InterpreterEngine ie); } |
Interpreter Context
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class InterpreterEngine { public int add(String input) { String[] tokens = interpret(input); int num1 = Integer.parseInt(tokens[0]); int num2 = Integer.parseInt(tokens[1]); return (num1 + num2); } public int subtract(String input) { String[] tokens = interpret(input); int num1 = Integer.parseInt(tokens[0]); int num2 = Integer.parseInt(tokens[1]); return (num2 - num1); } private String[] interpret(String input) { String str = input.replaceAll("[^0-9]", " "); str = str.replaceAll("( )+", " ").trim(); String[] tokens = str.split(" "); return tokens; } } |
As you can see our interpreter engine or context provides functionality to parse integers out of string and perform the requested operation on it.
Add Expression
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class AddExpression implements Expression { private String expression; public AddExpression(String expression) { this.expression = expression; } @Override public int interpret(InterpreterEngine ie) { return ie.add(expression); } } |
Subtract Expression
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class SubtractExpression implements Expression { private String expression; public SubtractExpression(String expression) { this.expression = expression; } @Override public int interpret(InterpreterEngine ie) { return ie.subtract(expression); } } |
You can see that our expression implementations are simply using the functionality provided by Interpreter Context.
Now let’s see how the actual client will send the input.
|
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 |
public class InterpreterClient { private InterpreterEngine ie; public InterpreterClient(InterpreterEngine ie) { this.ie = ie; } public int interpret(String input) { Expression exp = null; if(input.contains("add")) { exp = new AddExpression(input); } else if(input.contains("subtract")) { exp = new SubtractExpression(input); } int result = exp.interpret(ie); System.out.println(input); return result; } public static void main(String args[]) { InterpreterClient ic = new InterpreterClient(new InterpreterEngine()); System.out.println("Result = " + ic.interpret("add 12 and 13")); System.out.println("Result = " + ic.interpret("subtract 76 from 621")); } } |
Output:
So we have developed our own Domain Specific Language with the help of interpreter pattern.
Advantages
- We can create more than one interpreter for the same output and create the object of interpreter based on the given input.
- It’s easy to change and expand the grammar. Existing expressions can be easily modified, and new expressions can be defined on old ones.
Disadvantages
- If the grammar for day to day activity or processing easy then interpreter design pattern works the best. For complex instructions, your interpreter could become unmanageable.
Conclusion
The article helps you understand the interpreter pattern with a simple example.
You can download the code from our GitHub repository:
Download from Git
<Here are ALL other Java Design Patterns, explained in detail with examples>
