设计模式之简单工厂

1简单工厂

1.1简单工厂定义

提供创建对象的接口.简单工厂不属于23种设计模式里的

1.2UML类图

1.3简单工厂的使用场景

再不确定会有多少个处理操作时应该考虑使用简单工厂模式，如针对同样的接收到的数据，处理的逻辑可能会不同，可能以后还会增加新的操作。

例如如果实现计算器的功能时，对于同样的输入数据，可能执行加、减、乘、除，甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口，提供一个统一的处理方法(此处为process)，然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改，只编译修改的那个类或是新的类就可以了。
这样就做到了把耦合降到最低，同时也便于维护。

1.4案例(计算器)

1.4.1实现一个面向过程的计算器

package my.simpleFactor.v1;

import java.util.Scanner;

/** 写一个加减乘除计算器.面向过程写法
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class main {
    public static void main(String[] args) {
        System.out.println("请输入数字A");
        Scanner input=new Scanner(System.in);
        String numAStr = input.next();
        Integer numA = Integer.valueOf(numAStr);
        System.out.println("请输入运算符");
        String strOperate = input.next();
        System.out.println("请输入数字B");
        String numBStr = input.next();
        Integer numb = Integer.valueOf(numBStr);
        String total= "";
        switch (strOperate){
            case "+":
                total=numA+numb+"";
            break;
                    case "-":
                total=numA-numb+"";
            break;
                case "*":
                total=numA*numb+"";
            break;
                case "/":
                total=numA/numb+"";
                break;
                default:
                    break;
        }
        System.out.println("结果"+total);
    }

}

1.4.2实现一个面向对象的计算器(封装)

抽出一个算法类

package my.simpleFactor.v2;

/** 运算类
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class Operation {

    public static String getResutl(int numA,int numb,String operation){
       String total="";
        switch (operation){
            case "+":
                total=numA+numb+"";
                break;
            case "-":
                total=numA-numb+"";
                break;
            case "*":
                total=numA*numb+"";
                break;
            case "/":
                total=numA/numb+"";
                break;
            default:
                break;
        }

        return total;
    }





}

package my.simpleFactor.v2;

import java.util.Scanner;

/** 面向对象_1之继承解决面向过程
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class main {
    public static void main(String[] args){
        System.out.println("请输入数字A");
        Scanner input=new Scanner(System.in);
        String numAStr = input.next();
        Integer numA = Integer.valueOf(numAStr);
        System.out.println("请输入运算符");
        String strOperate = input.next();
        System.out.println("请输入数字B");
        String numBStr = input.next();
        Integer numb = Integer.valueOf(numBStr);
        String resutl = Operation.getResutl(numA, numb, strOperate);
        System.out.println("最终结果"+resutl);
    }
}

优点:面向对象 这样的做法成功将业务和界面(控制台)解耦
缺点 面向对象的作用还没实现最大功力.这样的做法 如果以后需要增加新的算法 开更 平方计算 需要去修改Operation 违反开闭原则. 紧耦合

1.4.3实现一个面向对象的计算器(封装+继承)

通过分析上面的缺点.我们可以将算法变成一个接口 或者通过集成的形式.这里采用继承的形式
算法父类

package my.simpleFactor.v3;

/**  定义一个算法抽象类
 * Created by Administrator on 2020/6/18.
 */
public abstract class Operation {

    public abstract String getResutl(int numA, int numb);

}

创建加法类继承算法类

package my.simpleFactor.v3;

/** 加法类
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class AddOperation extends Operation {

    public String getResutl(int numA, int numb) {

        return  numA+numb+"";
    }
}

创建减法类 继承算法类

package my.simpleFactor.v3;

/** 减法类
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class SubOperation extends Operation {

    public String getResutl(int numA, int numb) {
        return numA-numb+"";
    }
}

乘法

package my.simpleFactor.v3;

/** 乘法类
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class MulOperation extends Operation {

    public String getResutl(int numA, int numb) {

        return numA*numb+"";
    }
}

package my.simpleFactor.v3;

/** 除法类
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class DivOperation extends Operation {

    public String getResutl(int numA, int numb) {
        return numA/numb+"";
    }
}

优点上面将方法具体实现到具体的类里面了.所以一旦增加新算法只需要继承这个算法父类 实现算法方法即可
问题:如何让计算器知道我们要实现的是哪个算法类(利用简单工厂实例化)

1.4.3实现一个面向对象的计算器(简单工厂)(这里面包含了(封装+继承+多肽)的思想)

package my.simpleFactor.v3;

/**
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class OperationFactory {

    public static Operation createOperation(String operation){
        Operation o=null;
        switch (operation){
            case "+":
               o=new AddOperation();
                break;
            case "-":
                o=new SubOperation();
                break;
            case "*":
                o=new MulOperation();
                break;
            case "/":
                o=new DivOperation();
                break;
            default:
                break;
        }
    return o;
    }
}

package my.simpleFactor.v3;

/**
 * @Description
 * @Author fanjia
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2020/6/18
 */
public class main {
    public static void main(String[] args) {
        Operation operation = OperationFactory.createOperation("+");

        System.out.println(operation.getResutl(1,2));
    }
}

这样做已经完成了简单工厂

1.5简单工厂优缺点

优点业务和逻辑分离.将创建什么类的逻辑转移到了简单工厂里.
缺点:开闭原则还是没解决.以后有新的方法 还是要去简单工厂类修改代码.
(这就有了工厂方法模式)