设计模式Java版：15抽象工厂模式（创建型）

定义

抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。抽象工厂模式通过引入抽象工厂和具体工厂的概念，将对象的实例化操作封装在工厂类中，从而实现了对象的创建与使用相分离。

抽象工厂模式的定义如下：

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

在抽象工厂模式中，存在以下关键角色：

1. 抽象工厂（Abstract Factory）：定义了创建一系列产品的方法，每个方法对应一个具体产品族的创建。
2. 具体工厂（Concrete Factory）：实现抽象工厂接口，负责实例化具体产品对象。
3. 抽象产品（Abstract Product）：定义了产品的共同属性和方法，所有具体产品类的父类。
4. 具体产品（Concrete Product）：实现抽象产品接口，具体产品类由具体工厂创建。

抽象工厂模式通过引入工厂接口和产品接口的抽象层，使得客户端代码与具体工厂和产品的实现解耦，从而提供了一种灵活的扩展方式。客户端通过抽象工厂接口创建产品对象，而无需关心具体的实现细节，只需与抽象工厂和产品接口进行交互。

抽象工厂模式适用于以下场景：

1. 系统需要一次性创建一系列相关或相互依赖的产品对象。
2. 系统中存在多个产品族，且客户端只关心使用某个产品族的产品。
3. 需要提供一个统一的接口，用于创建一系列相关或相互依赖的产品。

总之，抽象工厂模式提供了一种灵活的方式来创建一系列相关或相互依赖的对象，同时将客户端与具体实现解耦，增强了系统的可扩展性和可维护性。

示例一：汽车制造

// 抽象产品：汽车
interface Car {
    void drive();
}

// 具体产品：奔驰汽车
class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Benz car...");
    }
}

// 具体产品：宝马汽车
class BMW implements Car {
    @Override
    public void drive() {
        System.out.println("Driving BMW car...");
    }
}

// 抽象产品：发动机
interface Engine {
    void start();
}

// 具体产品：奔驰发动机
class BenzEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Starting Benz engine...");
    }
}

// 具体产品：宝马发动机
class BMWEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Starting BMW engine...");
    }
}

// 抽象工厂：汽车工厂
interface CarFactory {
    Car createCar();
    Engine createEngine();
}

// 具体工厂：奔驰汽车工厂
class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }

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

// 具体工厂：宝马汽车工厂
class BMWFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new BMW();
    }

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

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建奔驰汽车工厂
        CarFactory benzFactory = new BenzFactory();
        // 创建奔驰汽车和发动机
        Car benzCar = benzFactory.createCar();
        Engine benzEngine = benzFactory.createEngine();
        // 使用奔驰汽车和发动机
        benzCar.drive();
        benzEngine.start();

        // 创建宝马汽车工厂
        CarFactory bmwFactory = new BMWFactory();
        // 创建宝马汽车和发动机
        Car bmwCar = bmwFactory.createCar();
        Engine bmwEngine = bmwFactory.createEngine();
        // 使用宝马汽车和发动机
        bmwCar.drive();
        bmwEngine.start();
    }
}

在以上示例中，我们完成了抽象工厂接口 CarFactory 的定义，并实现了两个具体工厂类 BenzFactory 和 BMWFactory。这两个具体工厂类分别实现了创建奔驰汽车和宝马汽车的方法，以及对应的发动机创建方法。

在客户端的 main 方法中，我们首先创建了奔驰汽车工厂 benzFactory，然后使用该工厂分别创建了奔驰汽车和发动机的实例，并通过调用其方法来驱动汽车和启动发动机。接着，我们创建了宝马汽车工厂 bmwFactory，并使用该工厂创建了宝马汽车和发动机的实例，同样通过调用其方法来使用宝马汽车和启动发动机。

输出结果：

Driving Benz car...
Starting Benz engine...
Driving BMW car...
Starting BMW engine...

通过这个完整的示例，我们展示了抽象工厂模式的使用，通过不同的具体工厂类创建了不同品牌的汽车和对应的发动机。这样，我们可以轻松地扩展和替换具体的工厂类，而不影响客户端的代码。

示例二：电子产品制造

下面是另一个简单的 Java 示例，展示了抽象工厂模式在电子产品制造中的应用。我们以手机和电视两种产品为例，展示了如何使用抽象工厂模式创建不同品牌的手机和电视：

// 抽象产品接口：手机
interface Phone {
    void makeCall();
}

// 具体产品类：小米手机
class XiaomiPhone implements Phone {
    @Override
    public void makeCall() {
        System.out.println("Making a call with Xiaomi phone...");
    }
}

// 具体产品类：华为手机
class HuaweiPhone implements Phone {
    @Override
    public void makeCall() {
        System.out.println("Making a call with Huawei phone...");
    }
}

// 抽象产品接口：电视
interface TV {
    void watch();
}

// 具体产品类：小米电视
class XiaomiTV implements TV {
    @Override
    public void watch() {
        System.out.println("Watching TV on Xiaomi TV...");
    }
}

// 具体产品类：华为电视
class HuaweiTV implements TV {
    @Override
    public void watch() {
        System.out.println("Watching TV on Huawei TV...");
    }
}

// 抽象工厂接口
interface ElectronicsFactory {
    Phone createPhone();
    TV createTV();
}

// 具体工厂类：小米工厂
class XiaomiFactory implements ElectronicsFactory {
    @Override
    public Phone createPhone() {
        return new XiaomiPhone();
    }

    @Override
    public TV createTV() {
        return new XiaomiTV();
    }
}

// 具体工厂类：华为工厂
class HuaweiFactory implements ElectronicsFactory {
    @Override
    public Phone createPhone() {
        return new HuaweiPhone();
    }

    @Override
    public TV createTV() {
        return new HuaweiTV();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建小米工厂
        ElectronicsFactory xiaomiFactory = new XiaomiFactory();
        // 创建小米手机和电视
        Phone xiaomiPhone = xiaomiFactory.createPhone();
        TV xiaomiTV = xiaomiFactory.createTV();
        // 使用小米手机和电视
        xiaomiPhone.makeCall();
        xiaomiTV.watch();

        // 创建华为工厂
        ElectronicsFactory huaweiFactory = new HuaweiFactory();
        // 创建华为手机和电视
        Phone huaweiPhone = huaweiFactory.createPhone();
        TV huaweiTV = huaweiFactory.createTV();
        // 使用华为手机和电视
        huaweiPhone.makeCall();
        huaweiTV.watch();
    }
}

在以上示例中，我们定义了抽象工厂接口 ElectronicsFactory，其中声明了创建手机和电视的方法。具体工厂类 HuaweiFactory 实现了该接口，并提供了创建华为手机和华为电视的具体实现。

在客户端的 main 方法中，我们创建了华为工厂 huaweiFactory，并使用该工厂分别创建了华为手机和华为电视的实例。然后，我们通过调用这些实例的方法，演示了使用华为手机打电话和观看华为电视的功能。

输出结果：

Making a call with Xiaomi phone...
Watching TV on Xiaomi TV...
Making a call with Huawei phone...
Watching TV on Huawei TV...

通过这个完整的示例，我们展示了抽象工厂模式在不同品牌手机和电视的创建中的应用。通过使用不同的具体工厂类，我们可以创建特定品牌的手机和电视，并且可以轻松地扩展和替换工厂类以支持更多品牌的产品。