二十三种设计模式-抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种方式，用于创建一系列相关或相互依赖的对象，而不需要指定它们具体的类。这种模式主要用于系统需要独立于其产品的创建逻辑时，并且需要能够提供一个产品族的不同变体。

抽象工厂模式的主要角色

抽象产品（Abstract Product）：定义了产品的接口，这些接口是具体产品必须实现的。
具体产品（Concrete Product）：实现了抽象产品的接口，这些是被创建的具体产品对象。
抽象工厂（Abstract Factory）：声明了一组工厂方法，用于创建抽象产品。
具体工厂（Concrete Factory）：实现了抽象工厂接口，生成一组相关或依赖的抽象产品对象。

抽象工厂模式的实现步骤

定义抽象产品：创建一个或多个抽象类或接口，定义产品需要实现的方法。
实现具体产品：为每种产品提供一个具体的类，实现或继承抽象产品类。
定义抽象工厂：创建一个包含多个创建产品方法的抽象类或接口，这些方法返回抽象产品类型的对象。
实现具体工厂：为每种产品族提供一个具体的工厂类，实现抽象工厂中的工厂方法，生成具体产品对象。

抽象工厂模式的代码示例

复制代码

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

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    public void use() {
        System.out.println("Using ProductA1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    public void use() {
        System.out.println("Using ProductA2");
    }
}

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

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    public void use() {
        System.out.println("Using ProductB1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    public void use() {
        System.out.println("Using ProductB2");
    }
}

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

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

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

// 客户端代码
public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.use();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.use();
    }
}

抽象工厂模式的优点

隔离接口和实现：客户端不需要知道具体的产品类，只需要知道抽象产品接口。
扩展性：增加新产品族时，不需要修改已有代码，只需要增加新的具体工厂和具体产品。
解耦：具体产品类的实现对客户端完全透明。

抽象工厂模式的缺点

增加新产品困难：增加新的具体产品需要扩展抽象工厂接口，这可能需要修改抽象工厂和所有具体工厂类。
系统复杂度：对于新的开发者来说，理解系统结构可能需要更多的时间。

抽象工厂模式和工厂方法模式（简单工厂模式）的区别

简单工厂模式（Simple Factory Pattern）

单一职责：简单工厂模式有一个工厂类负责所有相关产品的实例化工作。
创建方式：工厂类通常包含一个方法，根据传入的参数决定创建并返回哪种具体产品类的实例。
扩展性：增加新产品时，需要修改工厂类中的逻辑，违反了开闭原则。
产品族：简单工厂模式通常只负责一个产品等级结构的创建，即一个接口或抽象类下的所有具体类的创建。
代码简洁：实现简单，易于理解和使用。

抽象工厂模式（Abstract Factory Pattern）

多个工厂：抽象工厂模式包含多个工厂，每个工厂负责创建一族相关的产品。
创建方式：通过一组工厂方法来创建相关产品，每个工厂方法返回一个抽象产品类型的对象。
扩展性：增加新产品族时，只需增加一个新的具体工厂和对应的具体产品类，不需要修改已有代码，符合开闭原则。
产品族：抽象工厂模式可以处理多个产品等级结构，即多个接口或抽象类下的所有具体类的创建。
系统复杂度：实现较为复杂，需要定义多个抽象产品和工厂接口。