重学设计模式-抽象工厂模式

IT小东北

于 2023-11-19 15:42:13 发布

阅读量38

点赞数

文章标签：设计模式抽象工厂模式 java

本文链接：https://blog.csdn.net/weixin_46215308/article/details/134491414

版权

1.重学设计模式-带你体验一种不一样的学习之前言篇

2.重学设计模式-工厂方法模式

3.重学设计模式-抽象工厂模式

抽象工厂模式

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。抽象工厂模式是围绕一个超级工厂创建其他工厂该超级工厂又称为其他工厂的工厂。

通用类图

通用代码实现

包结构图

// 产品A 抽象类
public abstract class AbstractProductA {
   // 每个产品共有的方法
   public void shareMethod(){

  }
   // 每个产品相同方法,不同实现
   public abstract void doSomething();
}
// 产品A1 具体实现
public class ProductA1 extends AbstractProductA {
   @Override
   public void doSomething() {
       System.out.println("产品A1的实现方法");
  }
}
// 产品A2 具体实现
public class ProductA2 extends AbstractProductA {
   @Override
   public void doSomething() {
       System.out.println("产品A2的实现方法");
  }
}

// 产品B 抽象类
public abstract class AbstractProductB {
   // 每个产品共有的方法
   public void shareMethod(){

  }
   // 每个产品相同方法,不同实现
   public abstract void doSomething();
}
// 产品B1 具体实现
public class ProductB1 extends AbstractProductB {
   @Override
   public void doSomething() {
       System.out.println("产品B1的实现方法");
  }
}
// 产品B2 具体实现
public class ProductB2 extends AbstractProductB {
   @Override
   public void doSomething() {
       System.out.println("产品B2的实现方法");
  }
}

// 抽象工厂类
public abstract class AbstractCreator {
   //创建A 产品家族
   public abstract AbstractProductA createProductA();
   //创建B 产品家族
   public abstract AbstractProductB createProductB();
}
// 抽象工厂1的实现类 -- 产品等级为1的产品
public class Creator1 extends AbstractCreator{
   @Override
   public AbstractProductA createProductA() {
       return new ProductA1();
  }

   @Override
   public AbstractProductB createProductB() {
       return new ProductB1();
  }
}
// 抽象工厂2的实现类 -- 产品等级为2的产品
public class Creator2 extends AbstractCreator{
   @Override
   public AbstractProductA createProductA() {
       return new ProductA2();
  }

   @Override
   public AbstractProductB createProductB() {
       return new ProductB2();
  }
}

public class Client {
   public static void main(String[] args) {
       // 定义出俩个工厂
       AbstractCreator creator1=new Creator1();
       AbstractCreator creator2=new Creator2();

       AbstractProductA productA1 = creator1.createProductA();
       AbstractProductB productB1 = creator1.createProductB();

       AbstractProductA productA2 = creator2.createProductA();
       AbstractProductB productB2 = creator2.createProductB();
  }
}

在抽象工厂类AbstractCreator的指责是定义每个工厂要实现的功能，在通用代码中，抽象工厂类定义了俩个产品族的产品创建 （重点内容，productA和productB 被称为俩个产品族，而productA1和productA2以及productB1和productB2 统称为产品等级）。 有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务。

抽象工厂模式的优点

封装性：和工厂方法模式一样，它不关心对象是如何创建出来，只要知道工厂类是谁，我就能创建出一个需要的对象。例如我现在要创建产品等级为1 的产品，创建出Creator1，就能创建出产品等级为1的prodcutA1和productB1的俩个产品族对象。
产品族内的约束为非公开状态。可以在productA和productB的俩个产品族对象中创建各自需要的逻辑，也可以在对应工厂中。

抽象工厂模式的缺点

抽象工厂模式的最大缺点就是产品族扩展非常困难，例如现在要增加一个产品C。首先需要AbstractProductC抽象类，以及对应产品C相应的实现类，与此同时还需要在AbstractCreator 抽象工厂类中新增产品C的抽象方法，并且俩个工厂具体实现类中也需要增加对应的方法。这严重违反了开闭原则！！！！！！