场景描述

假设我们正在为一家汽车制造商设计一个车辆配置系统，该系统需要支持多种不同类型的汽车，如轿车、SUV、货车等。每种类型的汽车都有不同的配置选项，如引擎类型、内饰材料、安全功能等。此外，系统还应支持不同市场的特定要求，例如欧洲市场的汽车可能需要满足特定的排放标准，而美国市场的汽车则可能需要有更大的存储空间。这表明，不仅仅是汽车类型，还有市场特定的变体，都需要被系统支持。

抽象工厂模式比简单工厂模式的优点

1. 更好的扩展性

在这个场景中，如果使用简单工厂模式，每当需要增加新的汽车类型或市场特定要求时，都需要修改工厂类来添加新的创建逻辑，这违反了开闭原则（Open/Closed Principle）。而抽象工厂模式提供了一种更为灵活的解决方案，可以为每种类型的汽车和每个市场创建一个具体的工厂接口，这样就可以通过实现不同的工厂接口来支持新的汽车类型和市场，而无需修改现有的代码。

2. 更好的模块化

抽象工厂模式通过将相关对象的创建过程封装到同一个工厂接口中，实现了更高的模块化。例如，可以创建一个EuropeanCarFactory接口，该接口负责创建所有符合欧洲市场要求的汽车对象，包括轿车、SUV和货车。这样不仅使代码更加组织有序，也更容易理解和维护。

3. 支持复杂的对象依赖关系

在某些情况下，汽车的配置可能非常复杂，需要根据多种因素来决定最终的配置。抽象工厂模式允许在一个工厂中定义多个相关对象的创建过程，确保这些对象之间的依赖关系得到正确处理。例如，如果一个特定型号的轿车需要配备特定的引擎和内饰，这些依赖关系可以通过工厂方法来管理。

示例代码

// 抽象工厂接口
public interface CarFactory {
    Car createCar(String type);
    Engine getEngine(String type);
    Interior getInterior(String material);
}

// 具体工厂接口 - 欧洲市场
public class EuropeanCarFactory implements CarFactory {
    @Override
    public Car createCar(String type) {
        if (type.equals("sedan")) {
            return new Sedan(this);
        } else if (type.equals("suv")) {
            return new SUV(this);
        } else if (type.equals("van")) {
            return new Van(this);
        }
        throw new IllegalArgumentException("Unknown car type");
    }

    @Override
    public Engine getEngine(String type) {
        // 创建符合欧洲标准的引擎
        return new EuropeanEngine(type);
    }

    @Override
    public Interior getInterior(String material) {
        // 创建符合欧洲标准的内饰
        return new EuropeanInterior(material);
    }
}

// 抽象产品 - 汽车
public abstract class Car {
    protected Engine engine;
    protected Interior interior;

    public Car(CarFactory factory) {
        this.engine = factory.getEngine(getRequiredEngineType());
        this.interior = factory.getInterior(getRequiredInteriorMaterial());
    }

    protected abstract String getRequiredEngineType();
    protected abstract String getRequiredInteriorMaterial();
}

// 具体产品 - 轿车
public class Sedan extends Car {
    public Sedan(CarFactory factory) {
        super(factory);
    }

    @Override
    protected String getRequiredEngineType() {
        return "small";
    }

    @Override
    protected String getRequiredInteriorMaterial() {
        return "leather";
    }
}

// 具体产品 - SUV
public class SUV extends Car {
    public SUV(CarFactory factory) {
        super(factory);
    }

    @Override
    protected String getRequiredEngineType() {
        return "large";
    }

    @Override
    protected String getRequiredInteriorMaterial() {
        return "cloth";
    }
}

// 具体产品 - 货车
public class Van extends Car {
    public Van(CarFactory factory) {
        super(factory);
    }

    @Override
    protected String getRequiredEngineType() {
        return "commercial";
    }

    @Override
    protected String getRequiredInteriorMaterial() {
        return "basic";
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        CarFactory factory = new EuropeanCarFactory();
        Car sedan = factory.createCar("sedan");
        Car suv = factory.createCar("suv");
        Car van = factory.createCar("van");

        System.out.println(sedan.getEngine().getType());
        System.out.println(sedan.getInterior().getMaterial());
        System.out.println(suv.getEngine().getType());
        System.out.println(suv.getInterior().getMaterial());
        System.out.println(van.getEngine().getType());
        System.out.println(van.getInterior().getMaterial());
    }
}

总结

在这个场景中，抽象工厂模式不仅提供了更好的扩展性和模块化，还支持复杂的对象依赖关系，使得系统更加灵活和可维护。通过将相关对象的创建过程封装到同一个工厂接口中，可以更容易地支持新的汽车类型和市场特定要求，而无需修改现有的代码。