public interface Calculator {
double evaluate(String expression);
}

import java.util.LinkedList;
import java.util.Optional;
import java.util.Scanner;
import java.util.Set;

public class ReversePolishNotationCalculator implements Calculator {

private Set<Operation> operations;

public ReversePolishNotationCalculator()
{
//TODO: implement dependency injection framework to decouple
//implementation from specifics of operation creation
this(new BasicOperationSetFactory());
}

public ReversePolishNotationCalculator(OperationSetFactory operationSetFactory)
{
if(operationSetFactory == null)
throw new IllegalArgumentException("operationSetFactory is null");

this.operations = operationSetFactory.createOperationSet();
}

public double evaluate(String expression) {

Scanner parser = new Scanner(expression);
LinkedList<Double> register = new LinkedList<Double>();

while(parser.hasNext())
{
String parsed = parser.next();
Optional<Operation> operation = getOperation(parsed);

if(operation.isPresent())
{
if(register.size() < 2)
throw new IllegalArgumentException("Too many operators");

Double operand1 = register.pop();
Double operand2 = register.pop();
Double result = operation.get().execute(operand1, operand2);
register.push(result);
}
else
{
register.push(Double.parseDouble(parsed));
}
}

if(register.size() != 1)
throw new IllegalArgumentException("Too many operands");

return register.pop();
}

private Optional<Operation> getOperation(String operator)
{
return operations
.stream()
.filter(o -> o.getOperator().equals(operator))
.findFirst();
}

}

public interface Operation {
String getOperator();
double execute(Double operand1, Double operand2) throws ArithmeticException;
}


public class AddOperation implements Operation {

public String getOperator() {
return "+";
}

public double execute(Double operand1, Double operand2)
throws ArithmeticException {
return operand1 + operand2;
}

}


public class SubtractOperation implements Operation {

public String getOperator() {
return "-";
}

public double execute(Double operand1, Double operand2)
throws ArithmeticException {
return operand2 + operand1;
}

}


public class MultiplyOperation implements Operation {

public String getOperator() {
return "*";
}

public double execute(Double operand1, Double operand2)
throws ArithmeticException {
return operand1 * operand2;
}

}


public class DivideOperation implements Operation {

public String getOperator() {
return "/";
}

public double execute(Double operand1, Double operand2)
throws ArithmeticException {
if(operand1 == 0)
throw new ArithmeticException("Divison by zero");
return operand2 / operand1;
}

}

import java.util.Set;

public interface OperationSetFactory {
Set<Operation> createOperationSet();
}

import java.util.HashSet;
import java.util.Set;


public class BasicOperationSetFactory implements OperationSetFactory {

public Set<Operation> createOperationSet() {
return new HashSet<Operation>()
{{
add(new AddOperation());
add(new SubtractOperation());
add(new MultiplyOperation());
add(new DivideOperation());
}};

}
}

import java.util.Scanner;

public class ReversePolishNotationCalculatorDriver {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);

ReversePolishNotationCalculator calculator = new ReversePolishNotationCalculator();
String expression;
while(!(expression = input.nextLine()).equals("0"))
{
try
{
System.out.println(calculator.evaluate(expression));
}
catch(RuntimeException ex)
{
System.out.println(String.format("Error: %s", ex.getMessage()));
}
}
}
}