创建型模式-工厂模式，抽象工厂-优快云博客

本文链接：https://blog.youkuaiyun.com/wrxfxdd/article/details/143368675

1. 引言

在软件开发中，随着系统的复杂性不断增加，创建对象的方式也变得愈发复杂。如何有效地管理对象的创建过程，减少代码耦合度，提高代码的可维护性是每个开发者都要思考的问题。工厂模式作为一种创建型设计模式，正是为了解决这一问题而诞生的。

2. 工厂模式的定义

工厂模式是一种创建对象的设计模式，它提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。简单来说，工厂模式将对象的创建过程封装在工厂类中，使得客户端不需要了解具体的对象创建逻辑，只需与工厂类进行交互。

主要的工厂模式有三种：

简单工厂模式
工厂方法模式
抽象工厂模式

3. 简单工厂模式

3.1 定义

简单工厂模式是最基础的工厂模式，它通过一个工厂类根据提供的信息（如参数）返回不同类型的对象。

3.2 示例代码

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

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

// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("未知产品类型");
        }
    }
}

DiffCopyInsert

3.3 优缺点

优点：

封装了对象创建过程，减少了代码的耦合度。
客户端无需了解对象的具体类，只需通过工厂类创建和使用对象。

缺点：

工厂类集中了所有的产品创建逻辑，造成了工厂类的“膨胀”。
不易于扩展，增加新产品时需要修改工厂类。

4. 工厂方法模式

4.1 定义

工厂方法模式是对简单工厂模式的扩展，每一个产品的创建都由对应的工厂类来完成。客户端只需要依赖于抽象工厂，而不需要关心具体的产品实现。

4.2 示例代码

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

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

// 抽象工厂
abstract class Factory {
    public abstract Product createProduct();
}

// 具体工厂
class FactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

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

DiffCopyInsert

4.3 优缺点

优点：

消除了简单工厂模式的单一工厂问题。
客户端只需要依赖于工厂接口，易于扩展。

缺点：

可能会增加系统中类的数量。
工厂类数量可能较多，导致系统复杂性提高。

5. 抽象工厂模式

5.1 定义

抽象工厂模式提供一个接口，用于创建一系列相关或依赖的对象，而无需指定它们的具体类。

5.2 示例代码

// 抽象产品
interface ProductA {
    void use();
}

interface ProductB {
    void use();
}

// 具体产品
class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

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

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

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

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

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

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

DiffCopyInsert