Simple factory mode

1. Benefits of object orientation

Through encapsulation, inheritance and polymorphism, the coupling of programs is reduced.
Using design patterns makes programs more flexible, easy to modify, and easy to reuse.
It is maintainable, extensible, reusable and flexible.

2. Simple factory mode implementation

Simple addition, subtraction, multiplication and division:
Test main method

public class SimpleFactoryMain {
public static void main(String[] args) {
    String oprate ="/";
    Operation oper = SimpleFactory.operation(oprate);
    oper.setNumberA(2.0);
    oper.setNumberB(0);
    double result = oper.getResult();
    System.out.println(oper.getNumberA()+oprate+oper.getNumberB()+"="+result);
}
}

SimpleFactory simple factory

public class SimpleFactory {
    public static Operation operation(String operate) {
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new Add();
            break;
        case "-":
            oper = new Sub();
            break;
        case "*":
            oper = new Mul();
            break;
        case "/":
            oper = new Div();
            break;
        default:
            break;
        }
        return oper;
    }
}

Operatio operation class

/**
 * Operatio Arithmetic class
 *
 */
public class Operation {
    private double numberA = 0;
    private double numberB = 0;
    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
    public double getResult() {
        double result =0;
        return result;
    }
}

Addition operation

/**
 * Addition operation
 * @author 15680
 *
 */
public class Add extends Operation {
    @Override
    public double getResult() {
        double result =0;
        result = getNumberA()+getNumberB();
        return result;
    }
}

Subtraction operation

/**
 * Subtraction operations
 * @author 15680
 *
 */
public class Sub extends Operation {
    @Override
    public double getResult() {
        double result =0;
        result = getNumberA()-getNumberB();
        return result;
    }
}

Multiplication operation

/**
 * Multiplication class
 * @author 15680
 *
 */
public class Mul extends Operation {
    @Override
    public double getResult() {
        double result =0.0;
        result = getNumberA()*getNumberB();
        return result;
    }
}

Division operation

/**
 * Division operation class
 * @author 15680
 *
 */
public class Div extends Operation {
    @Override
    public double getResult() {
        double result =0.0;
        if(getNumberB()==0) {
            System.out.println("Divisor cannot be 0");
            return -1;
        }
        result= getNumberA()/getNumberB();
        return result;
    }
}