01简单工厂模式

简单工厂模式

顾名思义就是用来生产东西的工厂，而在面向对象中就是用来生产对象的。结合现实生活中的例子就是：告诉工厂我要生产什么要的产品，然后工厂根据这个客户的需求生产出这个产品给用户。
在面向对象程序的世界中就是：告诉简单工厂类，要生产什么类的对象，然后工厂返回这个对应类的对象。

例子：做一个计算器的实现，需要加减乘除等等的功能，而根据用户输入的符号来决定调用哪个类的对象来完成功能。这里的类和对象的实例化就可以交给简单工厂模式完成。

好处：当我们需要进行功能的扩展的时候可以直接编写好运算功能的子类如：开根号等，然后在简单工厂模式中添加，最后在主函数中直接使用就行。

UML图如下：

UML解释：

运算符类：是所有的运算符类的父类，而简单工厂类，返回的是指向子类对象(加减乘除)的父类变量。
以此来方便主函数中回调。
使用简单工厂设计模式的好处：当增加新的功能时，只需要编写运算符的子类，然后再简单工厂类中去实现它对应的实现逻辑即可。实现了扩展与主函数的分离。

运算符类（父类）：

package designPattern.Factory;

public class Operation {
    public  double numberA;
    public  double numberB;

    public Operation() {
    }

    //实例化运算符对象的时候传入两个运算符
    public Operation(double numberA, double numberB) {
        this.numberA = numberA;
        this.numberB = numberB;
    }
    public double GetResult(){
        return 0.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;
    }
}

加法类

package designPattern.Factory;

/**
 * 运算符的子类：加法类
 */
public class OperationAdd extends Operation {
    public OperationAdd() {

    }
    @Override
    public double GetResult(){
        return  this.numberA+this.numberB;
    }
}

减法类

package designPattern.Factory;

public class OperationSub extends Operation {
    public OperationSub() {

    }
    @Override
    public double GetResult(){
        return  this.numberA-this.numberB;
    }
}

乘法类

package designPattern.Factory;

public class OperationMul extends Operation{

    public OperationMul() {

    }

    @Override
    public double GetResult(){
        return  this.numberA*this.numberB;
    }
}

简单工厂类

package designPattern.Factory;


/**
 * 简单工厂模式——运算符工厂类：
 *      提供运算符子类的对象
 */
public class OperationFactory {

    //根据给的参数不同，返回不同的类的实例
    static Operation creatOperation(String operate){
        Operation oper = null;
        switch (operate){
            case "+" :
                oper = new OperationAdd();
                break;
            case "-" :
                oper = new OperationSub();
                break;
            case "*" :
                oper = new OperationMul();
                break;
            default:
                break;

        }
        return oper;
    }
}

主函数

package designPattern.Factory;

public class DoMain {
    public static void main(String[] args) {
        System.out.println("------------加法---------------");
        Operation operation = null;

        //通过工厂类：得到运算符的子类，然后通过统一的父类方法GetResult()计算结果
        operation =  OperationFactory.creatOperation("-");
        operation.setNumberA(10);
        operation.setNumberB(20);
        double result = operation.GetResult();
        System.out.println("结果为："+result);
    }
}

总结：

简单工厂模式用于生产对应类的实例对象，但是并不是所有的类的对象创建都要用工厂模式来做。
简单工厂模式：可以用于管理过多的类。使用过程中我们不必关系这个对象是哪个类的，我们只需要知道给工厂类传递什么参数能得到什么对象就行了。从过多的类中解放出来。

新手出道，有误之处，欢迎之处。