【JAVA设计模式】工厂模式详细解读之简单工厂模式

工厂模式可以分为三类：

1、简单工厂模式（Simple Factory）

2、工厂方法模式（Factory Method）

3、抽象工厂模式（Abstract Factory）

这三种模式逐步抽象，并且更具有一般性。在设计模式分类中都属于创建型模式。

创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。

创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。

创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。

工厂模式是创建型模式中比较重要的。工厂模式的主要功能就是帮助我们实例化对象。之所以名字中包含工厂模式四个字，是因为对象的实例化过程是通过工厂实现的，是用工厂代替new操作的。

接下来我们分别介绍下这三种工厂模式。

一、简单工厂模式

简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式，其实就是一种特殊的工厂方法模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

在介绍简单工厂模式之前，我们尝试解决以下问题：

现在我们要使用面向对象的形式定义计算器，为了实现各算法之间的解耦。主要的用到的类如下：

// 计算类的基类
@Setter
@Getter
public abstract class Operation {

    private double value1;

    private double value2;

    protected abstract double getResult();
}

// 加法
public class OperationAdd extends Operation {

    @Override
    protected double getResult() {
        return getValue1() + getValue2();
    }
}

// 减法
public class OperationSub extends Operation {

    @Override
    protected double getResult() {
        return getValue1() - getValue2();
    }
}

// 乘法
public class OperationMul extends Operation {

    @Override
    protected double getResult() {
        return getValue1() * getValue2();
    }
}

// 除法
public class OperationDiv extends Operation {

    @Override
    protected double getResult() {

        if (getValue2() == 0) {
            throw new IllegalArgumentException("除数不能为零");
        }
        return getValue1() / getValue2();
    }
}

当我们要执行运算时，可使用如下代码

public static void main(String[] args) {
    OperationAdd addOperation = new OperationAdd();
    addOperation.setValue1(1);
    addOperation.setValue2(2);
    System.out.println(addOperation.getResult());
}

当我需要执行减法运算时，我就要创建一个OperationSub类。也就是说，我想要使用不同的运算的时候就要创建不同的类，并且要明确知道该类的名字。

那么这种重复的创建类的工作其实可以放到一个统一的工厂类中。简单工厂模式有以下优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、屏蔽产品的具体实现，调用者只关心产品的接口。

简单工厂模式实现方式

简单工厂模式其实和他的名字一样，很简单。先来看看它的组成：

Factory：这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由 一个具体类实现。（OperationFactory）

Product：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。（Operation）

ConcreteProduct；工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 来用类图来清晰的表示下的它们之间的关系（OperationAdd\OperationSub等）

关系图如下：

在原有类的基础上，定义工厂类：

// 工厂类
public class OperationFactory {

    public static Operation create(String opt) {
        Operation operation;
        switch (opt) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new UnsupportedOperationException("不支持该操作");
        }
        return operation;
    }
}

有了工厂类之后，可以使用工厂创建对象：

Operation operation = OperationFactory.create("+");
operation.setValue1(1);
operation.setValue2(2);
System.out.println(operation.getResult());

通过简单工厂模式，该计算器的使用者不需要关心实现加法逻辑的那个类的具体名字，他只要知道该类对应的参数"+"就可以了。

简单工厂模式存在的问题

当我们需要增加一种计算时，例如开平方。这个时候我们需要先定义一个类继承Operation类，其中实现平方的代码。除此之外我们还要修改OperationFactory类的代码，增加一个case。这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。

我们举的例子是最简单的情况。而在实际应用中，很可能产品是一个多层次的树状结构。 简单工厂可能就不太适用了

简单工厂模式总结

工厂类是整个简单工厂模式的关键。包含了必要的逻辑判断，根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过使用工厂类，外界可以从直接创建具体产品对象的尴尬局面摆脱出来，仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的。明确了各自的职责和权利，有利于整个软件体系结构的优化。

但是由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

这些缺点在下篇博文工厂方法模式中得到了一定的解决。