简单工厂模式

简单工厂模式(不同于工厂模式):

介绍:
至少有一个工厂(Factory),工厂中至少有一个生产产品的机器(空的工厂没有什么意义)
构建一个顶级产品模板(产品顶级父类) 构建子产品模块(产品子类).
工厂将这些产品实例化,根据需要将工厂和产品产生联系实现相应操作

对应出现以下角色:
所有产品的顶级父类(模板)
继承父类的产品子类(a b c等子类…)

Ps:所有的模式都是利用java中的封装、继承、多态这三个特性展开的,都是为了达到“可维护”、“可扩展”、“可复用”这三个标准
优点:
使模块清晰化,各部分各司其职相对实现了可维护性

缺点:
添加新的功能需要新增加类的同时,还需要在是实例化类中添加判断分支

代码如下:
参照《大话设计模式》

计算器入口(main)

/**
 * 相当于客户端
 */
public class Controller {
    /**
     * 拆分出输入操作(也可以新建个类)
     *
     * @return
     */
    public static OperationClass inputDeal() {
        Scanner scanner = new Scanner(System.in);
        double numberA = scanner.nextDouble();
        String operation = scanner.next();
        double numberB = scanner.nextDouble();
        OperationClass operationClass = null;
        /**
         * 此处是简单工厂模式的核心操作
         * 调用工厂处理操作
         *  !!!!!此处必须赋值给operation,不然下边赋值会出现空指针异常
         */
        operationClass = ServiceClass.dealFactory(operation);
        // 因为使用构造方法时OperationClass对应的子类需要继承,选用set方法
        operationClass.setNumberA(numberA);
        operationClass.setNumberB(numberB);
        return operationClass;
    }


    public static void main(String[] args) throws Exception {
        OperationClass operationClass = inputDeal();
        double res = 0;
        try {
            // 由于在工厂处理是的动态绑定获取到了当前运行的类的类型,下边也就去相对应的类执行对应的方法
            res = operationClass.getRes();
        }
        // 捕获异常获得被除数为零的异常
        catch (Exception e) {
            System.out.println(e.getMessage());
            return;
        }
        System.out.println("结果是:" + res);
    }

}

工厂类(核心)

import designmodel.factorymodel.operationson.AddClass;
import designmodel.factorymodel.operationson.DivClass;
import designmodel.factorymodel.operationson.MultiClass;
import designmodel.factorymodel.operationson.RemoveClass;

/**
 * 简单工厂模式核心类 (*****)
 */
public class ServiceClass {
    private final static String add = "+";
    private final static String remove = "-";
    private final static String multi = "*";
    private final static String div = "/";

    public static OperationClass dealFactory(String operation) {
        OperationClass operationClass = null;
        switch (operation) {
            default:
                System.out.println("输入格式错误");
            case add:
                // 相当于在此时进行动态绑定(多态运行机制),确定该case语句运行的是add类,同时确定OperationClass的类型为ADD类
                operationClass = new AddClass();
                break;
            case remove:
                operationClass = new RemoveClass();
                break;
            case multi:
                operationClass = new MultiClass();
                break;
            case div:
                operationClass = new DivClass();
                break;
        }
        return operationClass;
    }

}

顶级父类(相当于产品模板)

/**
 * 计算顶级父类
 *
 */
public class OperationClass {

    private double numberA;
    private double numberB;

    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 getRes() throws Exception {
        double res=0;
        return res;
    }


}

其他子类(子产品模块)
ps:每个都是单独的类

=================加法==================

public class AddClass extends OperationClass {

    /**
     * 用来实现多态()
     * @return其他方法相同
     */
    @Override
    public double getRes() {
        double res=getNumberA()+getNumberB();
        return res;
    }
}


=================除法==================
public class DivClass extends OperationClass {

    @Override
    public double getRes() throws Exception {
        if (getNumberB()==0){
            throw new Exception("被除数不可以为0");
        }
        double res=getNumberA()/getNumberB();
        return res;
    }


}

=================乘法==================

public class MultiClass extends OperationClass {
    @Override
    public double getRes() throws Exception {
        double res=getNumberA()*getNumberB();
        return res;
    }
}

=================减法==================

public class RemoveClass extends OperationClass {


    @Override
    public double getRes() throws Exception {
        double res=getNumberA()-getNumberB();
        return res;
    }
}

设计模式初体验!!!