设计模式笔记 ------ 简单工厂模式

　　工厂模式三姐妹中，简单工厂无疑是最简单的。无论多简单的方法，放对了位置便是最佳实现，所以简单工厂在特定情况下还是有应用市场的。

定义：简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

　　总感觉百度百科上的这种定义说了等于没说。由于过于简单，所以在解释上会显得更繁琐，就像不能解释为什么1+1=2一样。

　　UML类图如下

　　具体实现中，产品类可以是接口（interface）或者是抽象类（abstract class），下面沿用《大话设计模式》一书中的例子（简单计算器的开发）加以说明。

　　首先是产品类，这里是运算符类，两个操作数参数和一个运算方法，此处用的是抽象类：

public abstract class Operation {
    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 abstract double getResult();
}

 　　具体产品衍生类，便是各个运算符的运算（加减乘除等），需要继承或实现产品类：

public class OperationAdd extends Operation {

    @Override
    public double getResult() {
        return getNumberA() + getNumberB();
    }
}
public class OperationSub extends Operation {

    @Override
    public double getResult() {
        return getNumberA() - getNumberB();
    }
}
public class OperationMul extends Operation {

    @Override
    public double getResult() {
        return getNumberA() * getNumberB();
    }
}
public class OperationDiv extends Operation {

    @Override
    public double getResult() {
        return getNumberA() / getNumberB();
    }
}

 　　工厂类即是创建运算类的类

public class OperationFactory {

    public static Operation createOperation(String what) {
        switch (what) {
        case "+":
            return new OperationAdd();
        case "-":
            return new OperationSub();
        case "*":
            return new OperationMul();
        case "/":
            return new OperationDiv();

        default:
            return null;
        }
    }
}

　　最后是客户端，调用

import java.util.Scanner;

public class POC {
    public static void main(String[] args) {
        coal();
    }

    public static void coal() {
        try {
            double numberA, numberB;
            String opr;
            @SuppressWarnings("resource")
            Scanner sc = new Scanner(System.in);
            System.out.println("输入第一个数字:");
            String numberAStr = sc.next();

            numberA = Double.parseDouble(numberAStr);
            System.out.println("输入操作符:");
            opr = sc.next();

            System.out.println("输入第二个数字:");
            String numberBStr = sc.next();
            numberB = Double.parseDouble(numberBStr);

            Operation operation = OperationFactory.createOperation(opr);
            operation.setNumberA(numberA);
            operation.setNumberB(numberB);
            System.out.println("结果是:"+operation.getResult());
        } catch (Exception e) {
            System.out.println("输入有误，请重新开始。。。");
            coal();
        }
    }
}

 

　　可是，我们为什么要用它呢？我们可以直接在客户端调用时直接new出对象，或者直接swith输入的操作符字符再做运算不就好了？这就牵涉到开发中需求更改或后期维护了。如果在这一模块开发完成后，突然需要一个开根号的运算需求，该如何做呢？如果没有用简单工厂，必将修改客户端代码。必须重新创建运算对象或更改对象。如果有成千上万个客户端呢？使用简单的目的在于：

直接目的：避免在代码中出现大量的new关键字
根本目的：将对象的创建统一起来便于维护和整体把控

　　使用工厂后，在运算需求更改或添加时，我们只需更改工厂类即可完成。

　　当然，万物有利有弊。工厂模式的弊端在于：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

　　简单工厂这种没有什么技术上的难度，纯粹是依照一些业务场景而出现的设计模式,甚至不属于23种GOF设计模式之一，是不同工厂模式的一个特殊实现。