设计模式之工厂模式

工厂模式的简单介绍

工厂模式是创建型模式之一，它主要的作用也是帮助我们创建对象。在工厂模式中，我们在创建对象时不会对用户暴露创建逻辑，并且是通过使用一个统一的接口来指向新创建的对象。

工厂模式又细分为三种：

• 简单工厂模式

  简单工厂模式可谓是最简单最实用的设计模式，我们只需要通过调用工厂为我们提供的一个方法就可以创建对象。这样虽然简单，但是有一个大的弊端就是，当我们新增一个商品时，需要去修改工厂类的代码，才可以使其为我们生产新的商品。这样会违背我们的设计原则，对扩展开放，对修改关闭。

  简单工厂就像是，新增产品需要把工厂关闭，重新进行修建，修建完成后可能会影响之前产品的生产。

  

• 工厂方法模式

  工厂方法模式就是为了改善简单工厂无法很好的保证扩展性的升级版本，我们通过构建一个抽象工厂，每次增加产品时，只需要增加一个对应的工厂实现类即可。使其可以完美的进行扩展，不需要影响以前的代码。

  工厂方法就像是，新增产品时，只需要加一个新产品的车间，丝毫不会干预到旧产品的生产。

  

• 抽象工厂模式

  抽象工厂使得工厂模式可以支持产品族的创建，创建有层级关系的产品。

  为什么会产生抽象工厂呢？就是因为简单工厂和工厂方法模式只能针对一类产品进行生产，如果想要生产其它商品只能再建一个工厂。比如说我们的工厂生产的抽象产品为汽车，那么我们就这能生产出各种汽车，而无法生产摩托车。抽象工厂的诞生就使得我们的工厂即可以生产不同型号的汽车，又可以生产不同型号的摩托车，还可以生产不同型号的飞机。

  

工厂模式的具体实现思路

• 简单工厂模式

  • 创建产品的抽象类 （一种产品）
  • 创建产品的具体实现 （不同规格的产品）
  • 创建工厂为每一种产品的具体实现，提供一个创建方法 （只有一个车间）

• 工厂方法模式

  • 创建产品的抽象类 （一种产品）
  • 创建产品的具体实现 （不同规格的产品）
  • 创建工厂的抽象类 （车间）
  • 为每一种产品创建一种工厂的实现类 （多个车间，每个车间生产一种规格的产品）

• 抽象工厂模式

  • 创建产品的抽象类多个 （多种产品）
  • 为每一种产品的抽象类创建具体实现 （为每一种产品提供多种规格的产品）
  • 创建工厂的抽象类，提供多种产品的生产方式 （定义工厂可以生产的品类）
  • 创建工厂的实现类，让其可以生产不同品类，不同规格的产品 （生产不同品类，不同规格的产品的具体厂家）

工厂模式的具体实现方案

• 简单工厂

  // 抽象产品
  public interface Product {
      void method();
  }
  // 产品A
  public class ProductA implements Product {
      public void method() {
          
      }
  }
  // 产品B
  public class ProductB implements Product {
      public void method() {
          
      }
  }
  // 工厂
  public class Factory {
      public Product createProduct(String productType) {
          if (productType.equalsIgnoreCase("A")) {
              return new ProductA();
          } else if(productType.equalsIgnoreCase("B")) {
              return new ProductB();
          }
          return null;
      }
  }

• 工厂方法

  // 抽象产品
  public interface Product {
      void method();
  }
  // 产品A
  public class ProductA implements Product {
      public void method() {
          
      }
  }
  // 产品B
  public class ProductB implements Product {
      public void method() {
          
      }
  }
  // 抽象工厂
  public interface Factory {
      Product create();
  }
  // 工厂A
  public class FactoryA implements Factory {
      public Product create() {
          return ProductA();
      }
  }
  // 工厂B
  public class FactoryB implements Factory {
      public Product create() {
          return ProductB();
      }
  }

• 抽象工厂

  // 抽象产品A
  public interface ProductA {
      void method();
  }
  // 产品A1
  public class ProductA1 implements ProductA {
      public void method() {
          
      }
  }
  // 产品A2
  public class ProductA2 implements ProductA {
      public void method() {
          
      }
  }
  // 抽象产品B
  public interface ProductB {
      void method();
  }
  // 产品B1
  public class ProductB1 implements ProductB {
      public void method() {
          
      }
  }
  // 产品B2
  public class ProductB2 implements ProductB {
      public void method() {
          
      }
  }
  // 抽象工厂
  public interface Factory {
      ProductA createProductA();
      ProductB createProductB();
  }
  // 工厂A
  public class FactoryA implements Factory {
      // 生产A产品
      public ProductA createProductA(String productType) {
          if (productType.equalsIgnoreCase("1")) {
              // 生产A产品规格为1的
              return new ProductA1();
          } else if(productType.equalsIgnoreCase("2")) {
              // 生产A产品规格为2的
              return new ProductA2();
          }
          return null;
      }
      // 生产B产品
      public ProductB createProductB(String productType) {
          if (productType.equalsIgnoreCase("1")) {
              return new ProductB1();
          } else if(productType.equalsIgnoreCase("2")) {
              return new ProductB2();
          }
          return null;
      }
  }
  // 工厂B
  public class FactoryB implements Factory {
      // 生产A产品
      public ProductA createProductA(String productType) {
          if (productType.equalsIgnoreCase("1")) {
              return new ProductA1();
          } else if(productType.equalsIgnoreCase("2")) {
              return new ProductA2();
          }
          return null;
      }
      // 生产B产品
      public ProductB createProductB(String productType) {
          if (productType.equalsIgnoreCase("1")) {
              return new ProductB1();
          } else if(productType.equalsIgnoreCase("2")) {
              return new ProductB2();
          }
          return null;
      }
  }

工厂模式的优缺点

• 简单工厂模式

  优点

  • 一个调用者想创建一个对象，只要知道其名称就可以了。
  • 扩展性高，如果想增加一个产品，只要扩展一个产品类就可以。
  • 将产品的具体实现封装起来，调用者只关心产品的接口。
  • 相对其他工厂方法来讲，代码简洁

  缺点

  • 每次增加一个产品时，都需要增加一个具体类，使得系统中类的个数成倍增加
  • 系统耦合度高，每次都需要修改创建产品的方法，不满足开闭原则

• 工厂方法模式

  优点

  • 一个调用者想创建一个对象，只要需要调用对应工厂的创建方法即可。
  • 扩展性高，如果想增加一个产品，只要扩展一个产品类和一个工厂类就可以。
  • 将产品的具体实现封装起来，调用者只关心产品的接口。
  • 完美的实现开闭原则

  缺点

  • 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加
  • 通过工厂模式创建对象复杂度会变高

• 抽象工厂模式

  优点

  • 满足了产品族的创建。
  • 将产品的具体实现封装起来，调用者只关心产品的接口。

  缺点

  • 工厂模式的缺点它都有

工厂模式的适用场景

• 简单工厂模式

  1. 工厂类负责创建的对象比较少，这样不会造成工厂方法中的业务逻辑太过复杂。
  2. 客户端需要传入工厂类不同的参数即可获得不同的产品，对于如何创建对象并不关心。

• 工厂方法模式

  1. 客户端可以不知道它所创建对象的类。
  2. 需要经常对产品进行扩展的。

• 抽象工厂模式

  1. 产品族的创建，有上下级关系的产品。

工厂模式总结

工厂模式有三种类型，每一种工厂模式都有它独特的特点，简单工厂模式和工厂方法模式应用场景相同，工厂方法模式的扩展性更好，也符合程序设计的开闭原则，但是需要创建大量的类，每添加一种商品都得对应的创建一个商品的具体实现和一个工厂的具体实现。抽象工厂更适合用在生产不同品类的产品，有层级关系的这种产品。