23种设计模式-抽象工厂(Abstract Factory)设计模式

🚩什么是抽象工厂设计模式？

抽象工厂模式（Abstract Factory Design Pattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。

与工厂方法模式的区别在于，抽象工厂模式通常用于处理产品族的创建，确保创建的对象是兼容的。

🚩抽象工厂模式的特点

• 封装性：抽象工厂模式将具体产品的创建过程封装在工厂内部，客户端无需关心具体的实现细节。

• 扩展性：当需要增加新的产品族时，只需增加新的工厂类，符合开闭原则。

• 一致性：抽象工厂模式确保创建的产品对象之间具有一致性，避免了不兼容的产品组合。

🚩抽象工厂模式的结构

抽象工厂模式通常包含以下几个角色：

• 抽象工厂（Abstract Factory）：定义创建一系列产品对象的接口。

• 具体工厂（Concrete Factory）：实现抽象工厂接口，负责创建具体的产品对象。

• 抽象产品（Abstract Product）：定义产品对象的接口。

• 具体产品（Concrete Product）：实现抽象产品接口，是具体工厂创建的对象。

• 客户端（Client）：使用抽象工厂和抽象产品接口来创建和使用产品对象。

图例：

🚩抽象工厂模式的优缺点

• 优点：

  1. 隔离具体类的生成：客户端不需要知道具体的产品类，只需要知道抽象工厂和抽象产品即可。

  2. 易于交换产品系列：只需改变具体的工厂类，就可以改变整个产品系列。

  3. 保证一致性：抽象工厂模式确保创建的产品对象之间具有一致性。

• 缺点：

  1. 增加系统复杂性：引入抽象工厂模式会增加类的数量，增加系统的复杂性。

  2. 不易扩展新产品：如果需要增加新的产品种类，需要修改抽象工厂接口及其所有子类，违反了开闭原则。

🚩抽象工厂方法的Java实现

代码地址：GitHub

1. 首先定义两个抽象产品（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();
}

2. 其次定义抽象工厂（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();
}

3. 现在创建具体产品（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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic void info() {System.out.println("产品的信息：B2");}
  }
  

4. 最后，我们创建具体工厂（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{@Overridepublic ProductA createProductA() {return new ProductA1();}@Overridepublic 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{@Overridepublic ProductA createProductA() {return new ProductA2();}@Overridepublic ProductB createProductB() {return new ProductB2();}
}

5. 最后来测试一下，可以发现我们下面的主函数代码，没有涉及到抽象工厂方法和抽象类，符合解耦原则

/*** @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 来创建不同的产品。客户端代码通过选择不同的工厂来创建不同的产品

🚩 总结

抽象工厂设计模式是一种强大的创建型设计模式，特别适用于需要创建一系列相关或相互依赖对象的场景。它通过封装具体产品的创建过程，确保了产品之间的一致性和兼容性。然而，抽象工厂模式也增加了系统的复杂性，并且在扩展新产品种类时可能会违反开闭原则。因此，在使用抽象工厂模式时，需要根据具体的应用场景进行权衡。

创作不易，不妨点赞、收藏、关注支持一下，各位的支持就是我创作的最大动力❤️