Interpreter Pattern

Pros

• e

Cons

• e

Example Explanation

[UML]

import java.util.Stack;

class Main {
  public static void main(String[] args) {

    String context = "5 2 3 7 20 8 + - / * %";

    Stack<IExpression> stack = new Stack<IExpression>();

    String [] splitContext = context.split(" ");
    for(String exp : splitContext){
      if( !SymbolParser.isSymbol(exp) ){
        stack.push( new NumberExpression(exp) );
      }
      else{
        IExpression left = stack.pop();
        IExpression right = stack.pop();
        IExpression symbol = SymbolParser.getExpression(left, right, exp);
        stack.push( new NumberExpression( symbol.interpret() ) );

      }
    }

    int finalValue = stack.pop().interpret();
    System.out.println( finalValue );

    //8 + 20
    //28 - 7
    //21 / 3
    //7 * 2
    //14 % 5
    //4
  }
}

interface IExpression{
  public int interpret();
}

class NumberExpression implements IExpression{

  private int number;

  public NumberExpression(String n){
    this.number = Integer.parseInt(n);
  }
  public NumberExpression(int n){
    this.number = n;
  }

  @Override
  public int interpret(){ return number; }
}

abstract class SymbolExpression{
  IExpression left;
  IExpression right;
  public SymbolExpression(IExpression left, IExpression right){
    this.left = left;
    this.right = right;
  }
}

class MultiplyExpression extends SymbolExpression implements IExpression{
  public MultiplyExpression(IExpression left, IExpression right){
    super(left, right);
  }
  @Override
  public int interpret(){
    System.out.println(left.interpret()+" * "+right.interpret());
    return left.interpret() * right.interpret();
  }
}

class AddExpression extends SymbolExpression implements IExpression{
  public AddExpression(IExpression left, IExpression right){
    super(left, right);
  }
  @Override
  public int interpret(){
    System.out.println(left.interpret()+" + "+right.interpret());
    return left.interpret() + right.interpret();
  }
}

class SubtractExpression extends SymbolExpression implements IExpression{
  public SubtractExpression(IExpression left, IExpression right){
    super(left, right);
  }
  @Override
  public int interpret(){
    System.out.println(left.interpret()+" - "+right.interpret());
    return left.interpret() - right.interpret();
  }
}

class ModulusExpression extends SymbolExpression implements IExpression{
  public ModulusExpression(IExpression left, IExpression right){
    super(left, right);
  }
  @Override
  public int interpret(){
    if(left.interpret() == 0 || right.interpret() == 0){
      return 0;
    }
    System.out.println(left.interpret()+" % "+right.interpret());
    return (int) left.interpret() % right.interpret();
  }
}

class DivisionExpression extends SymbolExpression implements IExpression{
  public DivisionExpression(IExpression left, IExpression right){
    super(left, right);
  }
  @Override
  public int interpret(){
    if(left.interpret() == 0 || right.interpret() == 0){
      return 0;
    }
    System.out.println(left.interpret()+" / "+right.interpret());
    return (int) left.interpret() / right.interpret();
  }
}

class SymbolParser{
  public static boolean isSymbol(String symbol){
    return symbol.equals("/") ||
           symbol.equals("%") ||
           symbol.equals("*") ||
           symbol.equals("-") ||
           symbol.equals("+");
  }
  public static IExpression getExpression(IExpression left, IExpression right, String symbol){

    if(symbol.equals("/")){
      return new DivisionExpression(left, right);
    }
    else if(symbol.equals("%")){
      return new ModulusExpression(left, right);
    }
    else if(symbol.equals("*")){
      return new MultiplyExpression(left, right);
    }
    else if(symbol.equals("-")){
      return new SubtractExpression(left, right);
    }
    else{
      return new AddExpression(left, right);
    }
  }
}

Extra Resources

https://springframework.guru/gang-of-four-design-patterns/interpreter-pattern/