设计模式——抽象工厂模式(Abstract Factory Pattern)

抽象工厂模式，顾名思义就是将工厂模式进行抽象化。

我建议在了解抽象工厂模式这个概念前，我们先了解一下工厂模式，这样会有助于您了解抽象工厂模式。

设计模式——工厂模式(Factory Pattern)

看到这里的小伙伴们，默认就是比较了解工厂模式的啦。那么其实抽象工厂模式其实就是将工厂模式生产的产品改为生产工厂。

接下来我继续借用一张图片来表明抽象工厂的概念。

通过上面的图片我们不难发现，抽象工厂只是在用户与工厂之间加了一层 “中间商” 。

我们再用实际生活举个例子，我们以前买零食要去零食店，买衣服要去服装店，买电视要去家电城。

但是现在我们只需要去购物商城，负一层卖零食，第一层卖服装，第二层卖家电，我们只需要了解第几层是卖什么的，不用再去想哪里才能买到我们想要的东西了(我们想要的东西都在购物商城里)。

代码示例：

1.首先我们要创建三个工厂接口，分别制造三种类型的产品

// 创建方便面接口
public interface FangBianMian {
   void taste();
}

// 创建衣服接口
public interface YiFu {
   void type();
}

// 创建笔记本接口
public interface BiJiBen {
   void pinPai();
}

2-1.创建方便面接口的实现

// 红烧味
public class HongShao implements FangBianMian {
 
   @Override
   public void taste() {
      System.out.println("红烧味方便面");
   }
}
 
// 香辣味
public class XiangLa implements FangBianMian {
 
   @Override
   public void taste() {
      System.out.println("香辣味方便面");
   }
}
 
// 酸辣味
public class SuanLa implements FangBianMian {
 
   @Override
   public void taste() {
      System.out.println("酸辣味方便面");
   }
}
 
// 小鲜虾味
public class XianXia implements FangBianMian {
 
   @Override
   public void taste() {
      System.out.println("鲜虾味方便面");
   }
}

2-2.创建衣服接口的实现

// 短袖
public class DuanXiu implements YiFu {
 
   @Override
   public void type() {
      System.out.println("短袖");
   }
}
 
// 衬衫
public class ChenShan implements YiFu {
 
   @Override
   public void type() {
      System.out.println("衬衫");
   }
}
 
// 外套
public class WaiTao implements YiFu {
 
   @Override
   public void type() {
      System.out.println("外套");
   }
}
 
// 毛衣
public class MaoYi implements YiFu {
 
   @Override
   public void type() {
      System.out.println("毛衣");
   }
}

2-3.创建笔记本接口的实现

// Mac品牌
public class Mac implements BiJiBen {
 
   @Override
   public void pinPai() {
      System.out.println("Mac笔记本");
   }
}
 
// 戴尔品牌
public class Dell implements BiJiBen {
 
   @Override
   public void pinPai() {
      System.out.println("戴尔笔记本");
   }
}
 
// 华为品牌
public class HuaWei implements BiJiBen {
 
   @Override
   public void pinPai() {
      System.out.println("华为笔记本");
   }
}

3.创建抽象类(按照工厂模式，接下来我们只需要创建工厂即可，但在抽象工厂中，我们必须提出一个抽象类，作为工厂的父类，用于合并多个工厂接口)

// 抽象工厂类，用于整合各个工厂
public abstract class AbstractFactory {
   // 获取方便面的抽象方法
   public abstract FangBianMian getFangBianMian(String taste);
   // 获取衣服的抽象方法
   public abstract YiFu getYiFu(String type);
   // 获取笔记本的抽象方法
   public abstract BiJiBen getBiJiBen(String pinPai);
}

4-1.进行方便面具体工厂创建，使用其进行具体产品制造

// 方便面工厂
public class FangBianMianFactory extends AbstractFactory {
    
   @Override
   public FangBianMian getFangBianMian(String taste){
      if(taste == null){
         return null;
      }        
      if(taste.equalsIgnoreCase("HONGSHAO")){
         return new HongShao();
      } else if(taste.equalsIgnoreCase("XIANGLA")){
         return new XiangLa();
      } else if(taste.equalsIgnoreCase("SUANLA")){
         return new SuanLa();
      }else if(taste.equalsIgnoreCase("XIANXIA")){
         return new XianXia();
      }
      return null;
   }
   
   @Override
   public YiFu getYiFu(String type) {
      return null;
   }

   @Override
   public BiJiBen getBiJiBen(String pinPai) {
      return null;
   }
}

4-2.进行衣服具体工厂创建，使用其进行具体产品制造

// 衣服工厂
public class YiFuFactory extends AbstractFactory {
    
   @Override
   public FangBianMian getFangBianMian(String taste){
      return null;
   }
   
   @Override
   public YiFu getYiFu(String type) {
      if(type == null){
         return null;
      }        
      if(type.equalsIgnoreCase("DUANXIU")){
         return new DuanXiu();
      } else if(type.equalsIgnoreCase("CHENSHAN")){
         return new ChenShan();
      } else if(type.equalsIgnoreCase("WAITAO")){
         return new WaiTao();
      }else if(type.equalsIgnoreCase("MAOYI")){
         return new MaoYi();
      }
      return null;
   }

   @Override
   public BiJiBen getBiJiBen(String pinPai) {
      return null;
   }
}

4-3.进行笔记本具体工厂创建，使用其进行具体产品制造

// 笔记本工厂
public class BiJiBenFactory extends AbstractFactory {
    
   @Override
   public FangBianMian getFangBianMian(String taste){
      return null;
   }
   
   @Override
   public YiFu getYiFu(String type) {
      return null;
   }

   @Override
   public BiJiBen getBiJiBen(String pinPai) {
      if(pinPai== null){
         return null;
      }        
      if(pinPai.equalsIgnoreCase("DUANXIU")){
         return new DuanXiu();
      } else if(pinPai.equalsIgnoreCase("CHENSHAN")){
         return new ChenShan();
      } else if(pinPai.equalsIgnoreCase("WAITAO")){
         return new WaiTao();
      }
      return null;
   }
}

5.创建超级工厂，用于创建各个产品的工厂

// 创建超级工厂
public class SuperFactory {
   public static AbstractFactory getFactory(String factoryType){
      if(factoryType == null){
         return null;
      }
      // equalsIgnoreCase方法表示忽略大小写比较值 
      if(choice.equalsIgnoreCase("FANGBIANMIAN")){
         return new FangBianMianFactory();
      } else if(choice.equalsIgnoreCase("YIFU")){
         return new YiFuFactory();
      } else if(choice.equalsIgnoreCase("BIJIBEN")){
         return new BiJiBenFactory();
      }
      return null;
   }
}

6.使用方法

public class Test {
   public static void main(String[] args) {
 
      //使用超级工厂获取获取具体产品工厂
      AbstractFactory yiFuFactory = SuperFactory.getFactory("YIFU");
 
      //获取外套的对象
      YiFu waiTao = yiFuFactory.getYiFu("WAITAO");
 
      //调用 waiTao 的 type 方法会打印   “外套”
      waiTao.type();
   }
}

通过最后的代码我们不难看出，抽象工厂模式就是通过两次索引来确定一个产品，第一次确定工厂，第二次在工厂内确定产品，如果到这里您还没有太理解什么是抽象工厂，那么接下来我再给您看一下我们这几个方法的关系图。

想必认真看的同学到这里应该就能理解抽象工厂模式了吧。接下来我们说一下抽象工厂模式的优缺点。

 优点：

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。(这句话我理解了一会才明白(可能理解的不对希望大佬指出)，用我们上面的例子举例，我想创建一个外套的对象，可是外套这个对象的创建需要借助笔记本的对象进行实现，接下来我们创建笔记本这个对象时可能另一个工厂也有这么一个同名的笔记本对象，我们就会创建出错误的对象，所以我们将需要配合的衣服工厂与笔记本工厂全部放在一个超级工厂下，就会避免创建错误对象的情况发生)。

缺点：

产品族扩展非常困难，每次新增产品族，既需要完成产品实现，还要完成产品抽象层的创建。

其他的内容在菜鸟教程中有比较详细的过程我就不在此赘述了，这篇文章的意义就是希望能够通过自己的理解尽可能形象的解释一下设计模式，使得抽象的内容理解起来变得简单些。

菜鸟教程|抽象工厂模式