抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们的具体类。抽象工厂模式常用于需要创建一组相关或依赖对象的场景，确保这些对象在不同的环境中可以协同工作。

特点

1. 抽象工厂：定义了一组创建产品的抽象方法，通常一个抽象工厂对应多个产品族（产品家族）。
2. 具体工厂：实现抽象工厂中的方法，创建一系列具体产品对象。
3. 抽象产品：定义了产品的接口，各具体产品类实现这个接口。
4. 具体产品：由具体工厂创建的实例，通常实现抽象产品接口。

实现

抽象工厂模式通过提供多个工厂接口的方法来创建产品，这些方法返回的通常是一组相关联的对象。

//抽象产品
//定义了所有汽车的公共接口，包含两个抽象方法 getType() 和 getColor()，分别用于获取汽车的类型和颜色。具体的汽车类会继承这个抽象类，并实现这些方法。
public abstract class AbstractCar {
    // 车的类型属性
    public abstract String getType();
    // 车的颜色属性
    public abstract String getColor();
}

// 具体产品HatchbackCar
public class HatchbackCar extends AbstractCar{
    private String type = "hatchback";
    private String color = "blue";
    @Override
    public String getType() {
        return type;
    }
    @Override
    public String getColor() {
        return color;
    }
}

// 具体产品JeepCar
public class JeepCar extends AbstractCar {
    private String type = "jeep";
    private String color = "green";
    @Override
    public String getType() {
        return type;
    }
    @Override
    public String getColor() {
        return color;
    }
}

// 具体产品SportCar
class SportCar extends AbstractCar{
    private String type = "sport";
    private String color = "red";
    @Override
    public String getType() {
        return type;
    }
    @Override
    public String getColor() {
        return color;
    }
}

// 抽象工厂
//抽象类定义了一个方法 createCar()，用于创建汽车。具体工厂类将继承这个抽象类并实现具体的创建方法。
public abstract class AbstractFactory {
    // 抽象方法： 创建一辆车
    public abstract AbstractCar createCar();
}

// 抽象工厂HatchbackCarFactory
public class HatchbackCarFactory extends AbstractFactory{
    @Override
    public AbstractCar createCar() {
        return new HatchbackCar();
    }
}
// 抽象工厂JeepCarFactory
public class JeepCarFactory extends AbstractFactory {
    @Override
    public AbstractCar createCar() {
        return new JeepCar();
    }
}
// 抽象工厂SportCarFactory
public class SportCarFactory extends AbstractFactory {
    @Override
    public AbstractCar createCar() {
        return new SportCar();
    }
}

//test
public class TestFactory {
    public static void main(String[] args) {
		//抽象工厂模式
        AbstractFactory hatchbackFactory = new HatchbackCarFactory();
        AbstractCar hatchbackCar = hatchbackFactory.createCar();
        System.out.println("恭喜你获得了一俩超酷的"+hatchbackCar.getColor()+" "+hatchbackCar.getType()+"车");

        AbstractFactory jeepFactory = new JeepCarFactory();
        AbstractCar jeepCar = jeepFactory.createCar();
        System.out.println("恭喜你获得了一俩凶猛的"+jeepCar.getColor()+" "+jeepCar.getType()+"车");

        AbstractFactory sportFactory = new SportCarFactory();
        AbstractCar sportCar = sportFactory.createCar();
        System.out.println("恭喜你获得了一俩拉风的"+sportCar.getColor()+" "+sportCar.getType()+"车");
    }
}

通过不同的工厂类创建不同类型的汽车对象（如 HatchbackCarFactory 创建掀背车，JeepCarFactory 创建越野车，SportCarFactory 创建跑车）。

优点

1. 一致性：确保由一个工厂生产的产品在同一个产品族中，彼此之间能很好地协同工作。
2. 易于交换产品族：更换一个产品族只需替换具体工厂，无需更改客户端代码。
3. 符合开闭原则：增加新的产品族时，只需新增具体工厂类，不需要修改已有代码。

缺点

1. 复杂性：随着产品族和产品种类的增加，系统会变得更复杂，增加了代码的维护难度。
2. 扩展困难：添加一个新产品（不是产品族）时，需要修改抽象工厂接口及其所有子类，违背了开闭原则。

使用场景

1. 系统需要独立于产品的创建和组合：例如跨平台的 GUI 应用，需要根据平台选择不同的控件（如按钮、文本框等）。
2. 产品族：系统需要由一组相互关联的产品组成，并且产品之间要求兼容，如操作系统的UI组件。
3. 切换产品族：需要在运行时更换产品族，而不影响客户端代码。

总结

抽象工厂模式适用于创建一组相关或互相依赖的对象，提供了一种使得产品族的创建与使用分离的机制。它使得产品族之间的切换非常容易，且确保了产品族内对象的一致性。然而，随着产品种类的增加，抽象工厂模式的扩展性会受到限制，需要谨慎设计。对于复杂且需要高扩展性的系统，抽象工厂模式是一个非常有力的工具。