抽象工厂模式：是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

抽象工厂模式的和工厂模式的区别在于：工厂模式是维护某类的实例、而抽象工厂模式是维护某类实例属于那个大类 场景 工厂模式：肯德基里面有炸鸡、有薯条….等等、那我们可以通过工厂模式创建出一个炸鸡实例！ 抽象工厂模式：炸鸡里面又细分：孜然味、原味、麻辣味、那通过抽象的形式把都属于炸鸡的维护起来形成一个族类！

  1. // 汽车产品
  2. class BMW{
  3.     constructor(){
  4.         this.name = '汽车-宝马'
  5.     }
  6.     run(){
  7.         console.log('car---BMW')
  8.     }
  9. }
  11. class BENZ{
  12.     constructor(){
  13.         this.name = '汽车-奔驰'
  14.     }
  15.     run(){
  16.         console.log('car---BENZ')
  17.     }
  18. }
  19. // 飞机产品
  20. class Helicopter{
  21.     constructor(){
  22.         this.name = '飞机-直升飞机'
  23.     }
  24.     run(){
  25.         console.log('aircraft-Helicopter')
  26.     }
  27. }
  29. // 抽象工厂类
  30. class AbstrctFactory{
  31.     getCar(){
  32.         throw new Error('请先实现子类方法')
  33.     }
  34.     getAircraft(){
  35.         throw new Error('请先实现子类方法')
  36.     }
  37. }
  39. // 汽车工厂
  40. class Car extends AbstrctFactory{
  41.     getCar(type){
  42.         switch(type){
  43.             case 'bmw':
  44.                 return new BMW()
  45.             case 'benz':
  46.                 return new BENZ()
  47.             default:
  48.                 break;
  49.         }
  50.     }
  51.     getAircraft(){
  52.         return null;
  53.     }
  54. }
  55. // 飞机工厂
  56. class Aircraft extends AbstrctFactory{
  57.     getAircraft(type){
  58.         switch(type){
  59.             case 'helicopter':
  60.                 return new Helicopter()
  61.             default:
  62.                 break;
  63.         }
  64.     }
  65.     getCar(){
  66.         return null;
  67.     }
  68. }
  71. // 超级工厂类
  72. class SuperFactory{
  73.     constructor(type){
  74.         switch (type) {
  75.             case 'car':
  76.                 return new Car();
  77.             case 'aircraft':
  78.                 return new Aircraft();
  79.             default:
  80.                 break;
  81.         }
  82.     }
  83. }
  85. // 根据抽象工厂获得汽车工厂
  86. let car = new SuperFactory('car');
  87. let mbwCar = car.getCar('bmw');
  88. mbwCar.run() // car---BMW
  90. // 根据抽象工厂获得飞机工厂
  91. let aircraft = new SuperFactory('aircraft');
  92. let helicopter = aircraft.getAircraft('helicopter');
  93. helicopter.run() // aircraft-Helicopter

总结

优点

  • 隔离了具体类的生成，使得客户端并不需要知道什么被创建
  • 当产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一产品族中的对象

  • 增加新的产品族很方便，无需修改已有系统代码、符合开闭原则

    缺点

  • 新增新的产品等级结构麻烦，需要对原有系统进行比较大的修改，甚至需要修改抽象层代码，违背了开闭原则

  • 增加了系统的抽象性和理解难度

    适用场景

  • 用户无需关心对象的创建过程，将对象的创建和使用进行解耦！

  • 产品等级结构稳定。在设计完成之后不会向系统新增或者删除产品等级结构

    超级工厂维护了很多产品类、通过超级工厂我们可以获取到具体的产品工厂类、在通过产品工厂类去实例化我们具体需要的项、抽象工厂模式这样让我们对工厂模式做了一个聚合的作用、缺点就是扩展很困难！