【23种设计模式】工厂模式：理论剖析与Java实践

工厂模式：理论、Java 实现与实践应用

一、工厂模式概述

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。通过使用工厂模式，可以将对象的创建逻辑封装在一个专门的工厂类中，而不是在客户端代码中直接使用 new 关键字来创建对象。这样做的好处是，当需要创建新的对象或者修改对象的创建逻辑时，只需要在工厂类中进行修改，而不会影响到使用这些对象的客户端代码，提高了代码的可维护性和可扩展性。

二、简单工厂模式

（一）理论介绍

简单工厂模式定义了一个工厂类，这个工厂类有一个创建对象的方法，根据传入的参数不同来创建不同类型的对象。它不属于 23 种设计模式中的一种独立模式，通常被看作是工厂模式的基础。

（二）代码实现

1. 首先创建一个产品接口：

public interface Product {
    void use();
}

2. 然后创建具体的产品类实现该接口：

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用 ConcreteProductA");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用 ConcreteProductB");
    }
}

3. 接着创建简单工厂类：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

（三）关键步骤

• 客户端代码通过调用简单工厂类的 createProduct 方法，并传入产品类型参数。
• 简单工厂类根据传入的参数判断需要创建哪种具体的产品对象，并返回给客户端。

（四）流程图

开始
|
|-- 客户端调用 SimpleFactory.createProduct 并传入类型参数
|   |
|   |-- SimpleFactory 判断参数
|   |   |
|   |   |-- 如果是 "A"，创建 ConcreteProductA 并返回
|   |   |
|   |   |-- 如果是 "B"，创建 ConcreteProductB 并返回
|   |   |
|   |   |-- 其他情况，返回 null
结束

三、工厂方法模式

（一）理论介绍

工厂方法模式定义了一个创建对象的抽象方法，由子类决定实例化的类。工厂父类负责定义创建产品的公共接口，而具体的工厂子类负责创建具体的产品对象。这样在增加新的产品时，只需要增加相应的工厂子类和产品子类，符合开闭原则。

（二）代码实现

1. 产品接口和具体产品类与简单工厂模式相同。
2. 创建抽象工厂类：

public abstract class Factory {
    public abstract Product createProduct();
}

3. 创建具体工厂类：

public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

（三）关键步骤

• 客户端代码首先确定需要使用的具体工厂类。
• 然后调用具体工厂类的 createProduct 方法，该方法创建并返回相应的具体产品对象。

（四）流程图

开始
|
|-- 客户端确定使用的具体工厂类（如 ConcreteFactoryA 或 ConcreteFactoryB）
|   |
|   |-- 调用具体工厂类的 createProduct 方法
|   |   |
|   |   |-- 具体工厂类创建并返回相应的产品对象（如 ConcreteProductA 或 ConcreteProductB）
结束

四、抽象工厂模式

（一）理论介绍

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它可以创建多个不同类型的产品对象，这些产品对象通常属于同一个产品族。

（二）代码实现

1. 定义多个产品接口：

public interface ProductA {
    void useA();
}

public interface ProductB {
    void useB();
}

2. 创建具体的产品类实现相应接口：

public class ConcreteProductA1 implements ProductA {
    @Override
    public void useA() {
        System.out.println("使用 ConcreteProductA1");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void useA() {
        System.out.println("使用 ConcreteProductA2");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void useB() {
        System.out.println("使用 ConcreteProductB1");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void useB() {
        System.out.println("使用 ConcreteProductB2");
    }
}

3. 创建抽象工厂类：

public abstract class AbstractFactory {
    public abstract ProductA createProductA();
    public abstract ProductB createProductB();
}

4. 创建具体的抽象工厂子类：

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

（三）关键步骤

• 客户端代码首先确定需要使用的具体抽象工厂子类。
• 然后通过该工厂子类创建一系列相关的产品对象。

（四）流程图

开始
|
|-- 客户端确定使用的具体抽象工厂子类（如 ConcreteFactory1 或 ConcreteFactory2）
|   |
|   |-- 调用具体抽象工厂子类的 createProductA 和 createProductB 方法
|   |   |
|   |   |-- 具体抽象工厂子类创建并返回相应的产品对象（如 ConcreteProductA1、ConcreteProductB1 或 ConcreteProductA2、ConcreteProductB2）
结束

五、工厂模式的应用场景

• 对象创建复杂时：当对象的创建过程涉及到复杂的逻辑，如读取配置文件、连接数据库等操作时，使用工厂模式可以将这些复杂的创建过程封装在工厂类中，使客户端代码更加简洁。例如创建数据库连接对象，不同的数据库（如 MySQL、Oracle）可能有不同的连接创建方式，通过工厂模式可以方便地创建对应的连接对象。
• 根据不同条件创建不同对象时：在软件系统中，根据不同的运行时条件（如用户输入、系统配置等）需要创建不同类型的对象，工厂模式可以很好地处理这种情况。比如在图形绘制系统中，根据用户选择绘制圆形或矩形，工厂模式可以根据用户的选择创建相应的圆形绘制对象或矩形绘制对象。

六、工厂模式的优缺点

（一）优点

• 解耦对象的创建和使用：使得代码的依赖关系更加清晰，使用者不需要了解对象的具体创建过程，只需要关心如何使用对象。
• 易于扩展：无论是简单工厂模式添加新的产品类型，还是工厂方法模式和抽象工厂模式增加新的产品族或产品，都相对容易实现，符合开闭原则。

（二）缺点

• 增加代码复杂度：引入工厂模式会增加代码的层次结构和类的数量，对于简单的应用场景可能会显得过于复杂。
• 抽象工厂模式的局限性：抽象工厂模式虽然可以创建一系列相关的产品，但当产品族中需要增加新的产品类型时，可能需要修改抽象工厂类及其所有子类，违反了开闭原则。

七、总结

工厂模式在 Java 编程中是非常重要的创建型设计模式，包括简单工厂模式、工厂方法模式和抽象工厂模式。它们各自适用于不同的场景，通过合理地运用工厂模式，可以提高代码的可维护性、可扩展性和灵活性，有效地管理对象的创建过程，为构建复杂的软件系统提供有力的支持。在实际项目开发中，需要根据具体的需求和系统架构来选择合适的工厂模式类型，以达到最佳的设计效果。