工厂模式

## 1 含义

1. 工厂模式提供了一种**创建对象的最佳方式**，
2. 在工厂模式中，我们在**创建对象时不会对客户端暴露创建逻辑**，而是**通过使用一个共同的接口来指向新创建的对象**，**实现了创建者和调用者的分离**。
3. 工厂模式可分为**简单工厂模式**、**工厂方法模式**、**抽象工厂模式**。

## 2 优缺点

### 2.1 优点

1. 工厂模式是我们**最常用的实例化对象模式**，**是用工厂方法代替 `new`操作的一种模式**。
2. 利用工厂模式可以**降低程序的耦合性**，**为后期的维护修改提供很大的便利**。
3. **将选择实现类**、**创建对象统一管理和控制**，从而**将调用者跟我们的实现类解耦**。

## 3 使用场景

1. 首先，作为一种**创建类模式**，在任何需要**生成复杂对象**的地方，都可以使用工厂模式，而对于**简单对象**，特别是**只需要 `new`就可以完成创建的对象**，**无需使用工厂模式**，因为如果**使用工厂模式**，就**需要引入一个工厂类**，**会增加系统的复杂度**。
2. 其次，工厂模式是一种典型的**解耦模式**，假如**调用者自己组装产品需要增加依赖关系时**，**可以考虑使用工厂模式**，这**会大大降低对象之间的耦合度**。
3. 最后，由于工厂模式是**依赖抽象架构**的，他**把实例化产品的任务交由实现类完成**，**扩展性比较好**，也就是说，当**需要系统有比较好的扩展性时**，**可以考虑工厂模式**，**不同的产品用不同的实现工厂来组装**。

## 4 分类

### 4.1 简单工厂模式

#### 4.1.1 含义

1. 简单工厂模式相当于**一个工厂中有各种产品**，**创建一个类时**，**客户无需知道具体产品的名称**，**只需要知道产品类所对应的参数即可**。
2. 但是**工厂的职责过重**，而且**类型过多时不利于系统的扩展维护**。

#### 4.1.2 UML类图

![](/media/202107/2021-07-10_1644230.7892239869809569.png)

#### 4.1.3 实例

1. 创建工厂：

```java
   public interface Car {
     void run();
   }
   ```
2. 创建工厂的产品（宝马）：

```java
   public class BMW implements Car {
       public void run() {
           System.out.println("我是宝马汽车...");
       }
   }
   ```
3. 创建另外一种产品（奥迪）：

```java
   public class AoDi implements Car {
       public void run() {
           System.out.println("我是奥迪汽车...");
       }
   }
   ```
4. 创建核心工厂类，由他决定具体调用哪种产品：

```java
   public class CarFactory {
       public static Car createCar(String name) {
           if (name.equals("奥迪")) {
               return new AoDi();
           }
           if (name.equals("宝马")) {
               return new BMW();
           }
           return null;
       }
   }
   ```
5. 创建演示工厂的具体实例：

```java
   public class FactoryTest {
       public static void main(String[] args) {
           Car aodi = CarFactory.createCar("奥迪");
           aodi.run();

Car bmw = CarFactory.createCar("宝马");
           bmw.run();
       }
   }
   ```

#### 4.1.4 优缺点

##### 4.1.4.1 优点

1. 简单工厂模式**能够根据外界给定的信息决定应该创建哪个具体类的对象**，**明确区分了各自的职责和权力**，**有利于整个软件体系结构的优化**。

##### 4.1.4.2 缺点

1. **工厂类集中了所有实例的创建逻辑**，**违反了高内聚责任分配原则**，**将全部创建逻辑集中到了一个工厂类中**，他所**能创建的类只能是事先考虑到的**，**如果需要添加新的类**，**就需要改变工厂类了**，**不利于系统的维护和扩展**。

### 4.2 工厂方法模式

#### 4.2.1 含义

1. 工厂方法模式又称**多态性工厂模式**，在工厂方法模式中，**核心的工厂类不再负责所有产品的创建**，而是**将具体创建的工作交给子类去做**，**核心的工厂类成为一个抽象工厂角色**，**仅负责给出具体工厂子类必须实现的接口**，而**不接触哪一个产品类应当被实例化这种细节**。

#### 4.2.2 UML类图

![](/media/202107/2021-07-10_1657050.4414884706162745.png)

#### 4.2.3 实例

1. 创建工厂：

```java
   public interface Car {
       void run();
   }
   ```
2. 创建工厂方法调用接口（所有的产品需要 `new`出来必须继承他来实现方法）：

```java
   public interface CarFactory {
       Car createCar();
   }
   ```
3. 创建工厂的产品（奥迪）：

```java
   public class AoDi implements Car {
       public void run() {
           System.out.println("我是奥迪汽车...");
       }
   }
   ```
4. 创建工厂另外一种产品（宝马）：

```java
   public class BMW implements Car {
       public void run() {
           System.out.println("我是宝马汽车...");
       }
   }
   ```
5. 创建工厂方法调用接口的实例（奥迪）：

```java
   public class AoDiFactory implements CarFactory{
       @Override
       public Car createCar() {
           return new AoDi();
       }
   }
   ```
6. 创建工厂方法调用接口的实例（宝马）：

```java
   public class BMWFactory implements CarFactory {
       @Override
       public Car createCar() {
           return new BMW();
       }
   }
   ```
7. 演示创建工厂的具体实例：

```java
   public class FactoryTest {
       public static void main(String[] args) {
           Car aodi = new AoDiFactory().createCar();
           aodi.run();

Car bmw = new BMWFactory().createCar();
           bmw.run();
       }
   }
   ```

#### 4.2.4 优缺点

##### 4.2.4.1 优点

1. **具有[简单工厂模式](#4-1-简单工厂模式)的所有[优点](#4-1-4-1-优点)**。
2. **扩展性高**，如果想**增加一个产品**，只需要**增加一个具体类**和**扩展一个工厂类**即可。

##### 4.2.4.2 缺点

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

### 4.3 抽象工厂模式

#### 4.3.1 含义

1. 抽象工厂简单地说就是**工厂的工厂**，**抽象工厂可以创建具体工厂**，由**具体工厂来生产具体产品**。

#### 4.3.2 UML类图

![](/media/202107/2021-07-10_1740100.01729989633633089.png)

#### 4.3.3 实例

1. 创建第一个工厂及其实现类：

```java
   public interface Car {
       void run();
   }

public class AoDi implements Car {
       public void run() {
           System.out.println("我是奥迪汽车...");
       }
   }

public class BMW implements Car {
       public void run() {
           System.out.println("我是宝马汽车...");
       }
   }
   ```
2. 创建第二个工厂及其实现类：

```java
   public interface Engine {
       void spin();
   }

public class AoDiEngine implements Engine{
       @Override
       public void spin() {
           System.out.println("转得快");
       }
   }

public class BMWEngine implements Engine{
       @Override
       public void spin() {
           System.out.println("转的慢");
       }
   }
   ```
3. 创建抽象方法调用接口及其实现类：

```java
   public interface AbstractFactory {
       Car createCar();
       Engine createEngine();
   }

public class AoDiFactory implements AbstractFactory{
       @Override
       public Car createCar() {
           return new AoDi();
       }

@Override
       public Engine createEngine() {
           return new AoDiEngine();
       }
   }

public class BMWFactory implements AbstractFactory{
       @Override
       public Car createCar() {
           return new BMW();
       }

@Override
       public Engine createEngine() {
           return new BMWEngine();
       }
   }
   ```
4. 运行测试：

```java
   public class FactoryTest {
       public static void main(String[] args) {
           AoDiFactory aoDiFactory = new AoDiFactory();
           Car aodi = aoDiFactory.createCar();
           aodi.run();
           Engine aodiEngine = aoDiFactory.createEngine();
           aodiEngine.spin();

BMWFactory bmwFactory = new BMWFactory();
           Car bmw = bmwFactory.createCar();
           bmw.run();
           Engine bmwEngine = bmwFactory.createEngine();
           bmwEngine.spin();
       }
   }
   ```

#### 4.3.4 优缺点

##### 4.3.4.1 优点

1. 抽象工厂模式**隔离了具体类的生成**，使得**客户并不需要知道什么时候被创建**，由于这种隔离，**更换一个具体的工厂就变得相对容易**，**所有的具体工厂都实现了抽象工厂中定义的那些公共接口**，因此**只需改变具体工厂的实例**，**就可以在某种程度上改变整个软件系统的行为**。
2. 当**一个产品族中的多个对象被设计成一起工作**时，他**能够保证客户端始终只使用同一个产品族中的对象**。
3. **增加新的产品族很方便**，**只需增加一个新的具体工厂即可**，**无需修改已有系统**。

##### 4.3.4.2 缺点

1. **增加新的产品结构很麻烦**，因为**需要修改所有的工厂角色**，**包括抽象工厂类**，**在所有的工厂类中都需要增加生产新产品的方法**，这**显然会带来较大不便**。

## 参考文献

1. [设计模式面试题（总结最全面的面试题！！！）](https://juejin.cn/post/6844904125721772039)。
2. [工厂模式——这一篇真够了](https://xie.infoq.cn/article/88c926822394aa1c80847dd2a)。
3. [设计模式之工厂模式（factory pattern）](https://www.cnblogs.com/yssjun/p/11102162.html)。