/**
     * Good luck with that. Especially when it grows from a scary one to a mean one.
     */
    public class ScaryCalculator
    {
        /**
         * Hard to maintain. 
         * Need to read through the if(s) and identify the code and variables that
         * you are interested. Not pleasant.  
         * 
         * Hard to extend.
         * Every time you need to add an operation you have to look at that scary
         * method and find a way to stick your code in it without messing with the 
         * rest. Not fun.
         * 
         * Not reusable.
         * You can't reuse any of the operations on a different class. Not efficient.
         */
        public int calculate(int x, int y, String operator)
        {
            if("+".equals(operator)){
                return x + y;
            }
            else if("-".equals(operator)){
                return x - y;
            }
            else if("*".equals(operator)){
                return x * y;
            }
            else if("/".equals(operator)){
                return x / y;
            }
            
            throw new UnsupportedOperationException(operator);
        }
    }


    /**
     * Hello polymorphism!
     */
    public class FunCalculator
    {
        /**
         * Interface to the rescue. Each operation is implemented differently.
         * So depepnding on the operation you pass in, you get a different result!
         * Oh the joy of polymorphism. (Maintenable)
         */
        public int calculate(int x, int y, Operation operation) {
        return operation.make(x, y);
        }
    }


    /**
     * Want to support a new Operation? Implement this interface! (Extensible)
     */
    public interface Operation
    {
        /**
         * Free to do any operation you like
         */
        public int make(int x, int y);
    }

    /**
     * Classes implementing that interface
     */
    public class Addition implements Operation
    {
        @Override
        public int make(int x, int y) {
        return x + y;
        }
    }

    public class Subtraction implements Operation
    {
        @Override
        public int make(int x, int y) {
        return x - y;
        }
    }

    public class Multiplication implements Operation
    {
        @Override
        public int make(int x, int y) {
        return x * y;
        }
    }

    public class Division implements Operation
    {
        @Override
        public int make(int x, int y) {
        return x / y;
        }
    }

    /**
     * Encapsulates the decision on which operation you get based on the operator.
     * Operations for everyone! (Reusable) 
     */
    public class OperationFactory
    {
        /**
         * Use a Map as an index for your operations!
         * Want to extend to include a new one? Simply put it in the Map!
         */
        private final Map<String, Operation> operations = 
            new HashMap<String, Operation>(){
                {
                    this.put("+", new Addition());
                    this.put("-", new Subtraction());
                    this.put("*", new Multiplication());
                    this.put("/", new Division());
                }
            };

        /**
         * @param operator what's your choice?
         */
        public Operation newOperation(String operator) 
        {
            Operation operation = this.operations.get(operator);
            
            /**
             * An innocent if
             */
            if(operation == null)
                throw new UnsupportedOperationException(operator);
            
        return operation;
        }
    }

    /**
     * Let's put it to the test
     */
    public class CalculatorTest
    {
        @Test
        public void make()
        {
            int x = 2;
            int y = 2;
            
            OperationFactory operationFactory = new OperationFactory();
            
            Operation addition = operationFactory.newOperation("+");        
            Operation subtraction = operationFactory.newOperation("-");        
            Operation multiplication = operationFactory.newOperation("*");
            Operation division = operationFactory.newOperation("/");        
            
            FunCalculator calculator = new FunCalculator();
            
            Assert.assertEquals(4, calculator.calculate(x, y, addition));
            Assert.assertEquals(0, calculator.calculate(x, y, subtraction));
            Assert.assertEquals(4, calculator.calculate(x, y, multiplication));        
            Assert.assertEquals(1, calculator.calculate(x, y, division));
        }
    }