🚩什么是抽象工厂设计模式？
抽象工厂模式（Abstract Factory Design Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。
与工厂方法模式的区别在于，抽象工厂模式通常用于处理产品族的创建，确保创建的对象是兼容的。
🚩抽象工厂模式的特点
封装性：抽象工厂模式将具体产品的创建过程封装在工厂内部，客户端无需关心具体的实现细节。
扩展性：当需要增加新的产品族时，只需增加新的工厂类，符合开闭原则。
一致性：抽象工厂模式确保创建的产品对象之间具有一致性，避免了不兼容的产品组合。
🚩抽象工厂模式的结构
抽象工厂模式通常包含以下几个角色：
抽象工厂（Abstract Factory）：定义创建一系列产品对象的接口。
具体工厂（Concrete Factory）：实现抽象工厂接口，负责创建具体的产品对象。
抽象产品（Abstract Product）：定义产品对象的接口。
具体产品（Concrete Product）：实现抽象产品接口，是具体工厂创建的对象。
客户端（Client）：使用抽象工厂和抽象产品接口来创建和使用产品对象。
🚩抽象工厂模式的优缺点
优点：
隔离具体类的生成：客户端不需要知道具体的产品类，只需要知道抽象工厂和抽象产品即可。
易于交换产品系列：只需改变具体的工厂类，就可以改变整个产品系列。
保证一致性：抽象工厂模式确保创建的产品对象之间具有一致性。
缺点：
增加系统复杂性：引入抽象工厂模式会增加类的数量，增加系统的复杂性。
不易扩展新产品：如果需要增加新的产品种类，需要修改抽象工厂接口及其所有子类，违反了开闭原则。
🚩抽象工厂方法的Java实现
代码地址：GitHub
- 首先定义两个
抽象产品（Product），里面有info方法
- ProductA：
/**
* @author hanson.huang
* @version V1.0
* @InterfaceName ProductA
* @Description 抽象产品A
* @date 2025/3/21 15:32
**/
public interface ProductA {
public void info();
}
- ProductB：
/**
* @author hanson.huang
* @version V1.0
* @InterfaceName ProductB
* @Description 抽象产品B
* @date 2025/3/21 15:33
**/
public interface ProductB {
public void info();
}
- 其次定义
抽象工厂（Creator），用于创建产品A和产品B
/**
* @author hanson.huang
* @version V1.0
* @InterfaceName Factory
* @Description 抽象工厂
* @date 2025/3/21 15:31
**/
public interface Factory {
public ProductA createProductA();
public ProductB createProductB();
}
- 现在创建
具体产品（Concrete Product），实现抽象产品接口，重写info方法
ProductA的具体实现：
- ProductA1：
/** * @author hanson.huang * @version V1.0 * @ClassName ProductA1 * @Description 具体产品A1 * @date 2025/3/21 15:36 **/ public class ProductA1 implements ProductA { @Override public void info() { System.out.println("产品的信息：A1"); } }- ProductA2：
/** * @author hanson.huang * @version V1.0 * @ClassName ProductA2 * @Description 具体产品A2 * @date 2025/3/21 15:36 **/ public class ProductA2 implements ProductA { @Override public void info() { System.out.println("产品的信息：A2"); } }ProductB的具体实现：
- ProductB1：
/** * @author hanson.huang * @version V1.0 * @ClassName ProductB1 * @Description 抽象产品B1 * @date 2025/3/21 15:37 **/ public class ProductB1 implements ProductB { @Override public void info() { System.out.println("产品的信息：B1"); } }- ProductB2：
/** * @author hanson.huang * @version V1.0 * @ClassName ProductB2 * @Description 抽象产品B2 * @date 2025/3/21 15:38 **/ public class ProductB2 implements ProductB { @Override public void info() { System.out.println("产品的信息：B2"); } }
- 最后，我们创建
具体工厂（Concrete Creator）来去实现抽象工厂接口，负责创建具体的对象，现在让工厂1创建产品A1和B1，让工厂2来创建产品A2和B2
- Factory1
/**
* @author hanson.huang
* @version V1.0
* @ClassName FactoryA
* @Description 具体工厂1，用于创建具体对象A1，B1
* @date 2025/3/21 15:35
**/
public class Factory1 implements Factory{
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
- Factory2
/**
* @author hanson.huang
* @version V1.0
* @ClassName Factory2
* @Description 具体工厂2，用于创建具体对象A2，B2
* @date 2025/3/21 15:40
**/
public class Factory2 implements Factory{
@Override
public ProductA createProductA() {
return new ProductA2();
}
@Override
public ProductB createProductB() {
return new ProductB2();
}
}
- 最后来测试一下，可以发现我们下面的主函数代码，没有涉及到抽象工厂方法和抽象类，符合解耦原则
/**
* @author hanson.huang
* @version V1.0
* @ClassName AbstractFactory
* @Description main
* @date 2025/3/21 15:31
**/
public class AbstractFactory {
public static void main(String[] args) {
Factory1 factory1 = new Factory1();
ProductA productA = factory1.createProductA();
productA.info();
Factory2 factory2 = new Factory2();
ProductB productB = factory2.createProductB();
productB.info();
}
}
🚩 代码总结
在这个示例中，我们定义了两个产品族：ProductA 和 ProductB ，并为每个产品族提供了具体实现：ProductA1、ProductA2和ProductB1、ProductB2 。然后，我们定义了一个抽象工厂 Factory，并提供了两个具体工厂 Factory1 和 Factory1 来创建不同的产品。客户端代码通过选择不同的工厂来创建不同的产品
🚩 总结
抽象工厂设计模式是一种强大的创建型设计模式，特别适用于需要创建一系列相关或相互依赖对象的场景。它通过封装具体产品的创建过程，确保了产品之间的一致性和兼容性。然而，抽象工厂模式也增加了系统的复杂性，并且在扩展新产品种类时可能会违反开闭原则。因此，在使用抽象工厂模式时，需要根据具体的应用场景进行权衡。
创作不易，不妨点赞、收藏、关注支持一下，各位的支持就是我创作的最大动力❤️
