Simple factory mode

Simple factory model

Introducing problems

Using any object-oriented language to implement a calculator console program , Two numbers and operation symbols are required , Get the results .

【 Common code 】

Although such a program solves the problem , But not easy to maintain , It's not easy to expand , It's not easy to reuse . So it can't meet the requirement of high quality code .

explain ： The picture comes from the big talk design pattern , For learning purposes only .

【 Factory mode code 】

The title mentions the use of object orientation , Then the three characteristics of object-oriented are encapsulation 、 Inheritance and polymorphism .

We can try to encapsulate the computing class , And divide different operations to write , Be decoupled , And use the factory model .

The structure is as follows ：

【Java】

Operation class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: Operation * @Description:  Operation parent class  * @author:  Cowherd Conan  * @date: 2022-06-22 19:10 */
public class Operation {
    
    private double numA;
    private double numB;

    public double getNumA() {
    
        return numA;
    }

    public void setNumA(double numA) {
    
        this.numA = numA;
    }

    public double getNumB() {
    
        return numB;
    }

    public void setNumB(double numB) {
    
        this.numB = numB;
    }

    public double getResult() throws Exception {
    
        double res = 0;
        return res;
    }
}

Add class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: OperationAdd * @Description:  Add operation  * @author:  Cowherd Conan  * @date: 2022-06-22 19:13 */
public class OperationAdd extends Operation{
    

    @Override
    public double getResult() {
    
        return getNumA() + getNumB();
    }
}

Subtraction class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: OperationSub * @Description:  Subtraction operation  * @author:  Cowherd Conan  * @date: 2022-06-22 19:18 */
public class OperationSub extends Operation{
    

    @Override
    public double getResult() {
    
        return getNumA() - getNumB();
    }
}

Multiplication class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: OperationMul * @Description:  Multiplication  * @author:  Cowherd Conan  * @date: 2022-06-22 19:19 */
public class OperationMul extends Operation{
    

    @Override
    public double getResult() {
    
        return getNumA() * getNumB();
    }
}

Divide the class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: OperationDiv * @Description:  In addition to the operation  * @author:  Cowherd Conan  * @date: 2022-06-22 19:20 */
public class OperationDiv extends Operation{
    

    @Override
    public double getResult() throws ArithmeticException {
    
        if(getNumB()==0){
    
            throw new ArithmeticException(" The divisor cannot be zero 0！");
        }
        return getNumA() / getNumB();
    }
}

Simple factory class

package keafmd.accumulate.designmode.factorymode;

/** * Keafmd * * @ClassName: OperationFactory * @Description:  Computing factory  * @author:  Cowherd Conan  * @date: 2022-06-22 19:23 */
public class OperationFactory {
    
    public static Operation createOperation(String operate) throws Exception {
    
        Operation operation = null;
        switch (operate){
    
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new Exception(" Illegal input operator ！");
        }
        return operation;
    }
}

client

package keafmd.accumulate.designmode.factorymode;

import java.util.Scanner;

/** * Keafmd * * @ClassName: ComputingClient * @Description:  Computing client  * @author:  Cowherd Conan  * @date: 2022-06-22 19:29 */
public class ComputingClient {
    
    public static void main(String[] args) throws Exception {
    
        Scanner sc = new Scanner(System.in);
        System.out.println(" Please enter two numbers ：");
        double a = sc.nextDouble();
        double b = sc.nextDouble();
        System.out.println(" Please enter operator （+,-,*,/）：");
        String s = sc.next();
        Operation operation = OperationFactory.createOperation(s);
        operation.setNumA(a);
        operation.setNumB(b);
        System.out.println(" The result of operation is ：" + operation.getResult());

    }
}

effect

 Please enter two numbers ：
2
3
 Please enter operator （+,-,*,/）：
*
 The result of operation is ：6.0

Process finished with exit code 0

That's all about the simple factory model

Copyright notice ：
Original Blogger ： Cowherd Conan
Blogger original link ：https://keafmd.blog.csdn.net/
Personal blog links ：https://www.keafmd.top/

If it helps you , Thank you for clicking on the like support below ！
[ ha-ha ][ Huai Quan ]

come on. ！

Joint efforts ！

Keafmd