你还在new对象吗？用个“抽象工厂模式”生产对象它不香吗！

今天跟大家分享一下工厂设计模式家族中的“抽象工厂模式”。

简介

了解工厂模式的都知道，工厂模式就是用于大量创建某种，某类，或者某批对象时的一种优秀的解决方案。本文介绍的“抽象工厂模式”就是工厂模式的一种体现，是属于建造型模式的一种。

抽象工厂模式中有四个角色：分别是抽象产品角色，具体产品角色，抽象工厂角色，具体工厂角色。

其实“抽象工厂模式”很好理解，我给大家举个小例子，各位优秀的读者们应该就可以看懂了，看的时候记得将上面的四种角色代入进去，这样方便大家理解与记忆。

一个老板，想要生产汽车（这里所说的汽车，并没有指出具体的类型，只是一个大的方向，它对应的就是“抽象产品角色”）。

一开始创业肯定是规模较小，从而选择生产国产汽车，比如：国产轿车、SVU等等（这提出的轿车，就是一个具体的产品，它对应的就是“具体产品角色”），此时一个工厂就可以了。

当老板经过一段时间的经营后，赚钱了想要扩展，不满足只生产“国产车”了，还想生产“合资车”，这时候又需要再开一个工厂。随着产业的不断发展，以后肯定会涉及到其它汽车，比如用电的、用油的……那么作为一个老板为了方便管理，肯定需要设立一个“总公司”（总公司对应的就是“抽象工厂角色”），制定一套规范，让其它子公司（子公司对应的就是“具体工厂角色”）都遵守。但是具体子公司怎么把汽车制造出来，总公司不需要了解。

我们把这样的一套模式，应用到编程中，就形成了“抽象工厂模式”。

代码

通过单纯的文字描述可能大家理解的不是特别的清晰，下面我们就是将文字转换成代码，从而加深大家对“抽象工厂模式”的理解。

“抽象产品角色”对应的代码：

/**
 * 车辆抽象类
 */
public abstract class Vehicle {

  /**
   * 生产车的抽象方法
   */
  public abstract void production();
}

“具体产品角色”对应的代码：

/**
 * 国产轿车
 */
public class DomesticCar extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆国产轿车！");
  }
}

/**
 * 国产SUV
 */
public class DomesticSUV extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆国产SUV！");
  }
}

/**
 * 国产货车
 */
public class DomesticTruck extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆国产货车！");
  }
}

/**
 * 合资轿车
 */
public class JointVentureCar extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆合资轿车！");
  }
}

/**
 * 合资SUV
 */
public class JointVentureSUV extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆合资SUV！");
  }
}

/**
 * 合资货车
 */
public class JointVentureTruck extends Vehicle {

  @Override
  public void production() {
    System.out.println("生产出一辆合资货车！");
  }
}

“抽象工厂角色”对应的代码：

/**
 * 抽象工厂接口
 */
public interface AbsFactory {

  // 创建车辆子类实例的方法。
  Vehicle createVehicle(String vehicleType);

}

“具体工厂角色”对应的代码：

/**
 * 生产国产车的工厂
 */
public class DomesticFactory implements AbsFactory {

  @Override
  public Vehicle createVehicle(String vehicleType) {
    Vehicle vehicle = null;
    switch (vehicleType) {
      case "car":
        vehicle = new DomesticCar();
        break;
      case "suv":
        vehicle = new DomesticSUV();
        break;
      case "truck":
        vehicle = new DomesticTruck();
        break;
    }
    return vehicle;
  }
}

/**
 * 生产合资车的工厂
 */
public class JointVentureFactory implements AbsFactory {

  @Override
  public Vehicle createVehicle(String vehicleType) {
    Vehicle vehicle = null;
    switch (vehicleType) {
      case "car":
        vehicle = new JointVentureCar();
        break;
      case "suv":
        vehicle = new JointVentureSUV();
        break;
      case "truck":
        vehicle = new JointVentureTruck();
        break;
    }
    return vehicle;
  }
}

测试类：

public class Demo {

  public static void main(String[] args) {
    AbsFactory domesticFactory = new DomesticFactory();
    domesticFactory.createVehicle("car").production();
    JointVentureFactory jointVentureFactory = new JointVentureFactory();
    jointVentureFactory.createVehicle("car").production();
  }
}

总结

优点：

实例化对象时不需要单独创建，只要通过工厂类就可以得到，大大提高了代码的复用性。并且也不必考虑创建对象的过程，只关注结果就可以，从而也提高了软件的封装性。

缺点：

抽象工厂模式不利于软件的扩展，每次新增产品时需要修改很多类。

今天的分享就到这里了，如果感觉“菜鸟”写的文章还不错，记得点赞加关注呦！你们的支持就是我坚持下去的动力。文章哪里写的有问题的也希望大家可以指出，我会虚心受教。