什么是工厂模式？

顾名思义，工厂模式是现实生活中工厂的映射，由个人生产商品（new对象）变成由专业的工厂生产商品。
按照生产产品的场景不同，工厂模式分为，简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式对应农耕社会小作坊，工厂方法模式对应业革命流水线，抽象工厂对应现代产业链代工厂。我们的项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单。

  • 简单工厂模式解决了产品的生产问题，生产和消费分离
  • 工厂方法模式解决了产品由谁生产的问题，用户开始关注品牌，工厂和产品分离


使用场景

复杂对象的创建，对象创建和业务解耦分离，上述复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。

简单工厂模式 Simple Factory Pattern

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

对应小工作坊，比如小酒厂，提供高粱酒、小麦酒等产品，用户不关心制作过程。

代码实现

  • 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
  • 具体产品（ProductA和ProductB）：是简单工厂模式的创建目标。
  • 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。 ```java

/**

  • 产品 */ interface Product { }

/**

  • 产品A */ class ProductA implements Product { }

/**

  • 产品B */ class ProductB implements Product { }

/**

  • 产品类型 */ enum ProductType { //产品A A, //产品B B; }

class SimpleFactory { /**

  1.  * 根据参数创建相应的产品
  2.  *
  3.  * @param productType 产品类型
  4.  * @return 具体的产品 Product
  5.  */
  6. public static Product makeProduct(ProductType productType) {
  7.     switch (productType) {
  8.         case A:
  9.             return new ProductA();
  10.         case B:
  11.             return new ProductB();
  12.         default:
  13.             return null;
  14.     }
  15. }

}

//简单工厂测试 public class SimpleFactoryPattern { public static void main(String[] args) { Product a = SimpleFactory.makeProduct(ProductType.A); Product b = SimpleFactory.makeProduct(ProductType.B);

  1.     System.out.println(a);
  2.     System.out.println(b);
  3. }

}

  1. <a name="1PXmL"></a>
  2. ## JDK中的简单工厂模式
  3. Java中的Calendar类，在创建Calendar实例时，就使用了简单工厂。
  4. <a name="CZskL"></a>
  5. # 工厂方法模式 Factory Method Pattern
  6. 对应现实中流水线工厂，用户只知道创建产品的工厂名，而不知道具体的产品名，还是拿酒来说，如 青岛啤酒、崂山啤酒等。<br />青岛啤酒厂可以生产高粱酒，也可以生产小麦酒。<br />崂山啤酒厂也可以生产高粱酒，也可以生产小麦酒。<br />用户更关注品牌。
  7. <a name="HtC03"></a>
  8. ## 代码实现
  10. - 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  11. - 具体产品（ProductA，ProductB）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
  12. - 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
  13. - 具体工厂（Factory1，Factory2）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
  14. ```java
  16. /**
  17.  * 产品
  18.  */
  19. interface Product {
  20. }
  22. /**
  23.  * 产品A
  24.  */
  25. class ProductA implements Product {
  26. }
  28. /**
  29.  * 产品B
  30.  */
  31. class ProductB implements Product {
  32. }
  34. /**
  35.  * 产品类型
  36.  */
  37. enum ProductType {
  38.     //产品A
  39.     A,
  40.     //产品B
  41.     B;
  42. }
  44. /**
  45.  * 工厂方法类接口
  46.  */
  47. interface FactryMeathod {
  48.     //抽象生产产品方法
  49.     Product makeProduct(ProductType productType);
  50. }
  52. /**
  53.  * 工厂1
  54.  * 可以生产产品A也可以生产产品B
  55.  */
  56. class FactryMeathod1 implements FactryMeathod {
  57.     /**
  58.      * 根据参数创建相应的产品
  59.      *
  60.      * @param productType 产品类型
  61.      * @return 具体的产品 Product
  62.      */
  63.     @Override
  64.     public Product makeProduct(ProductType productType) {
  65.         switch (productType) {
  66.             case A:
  67.                 return new ProductA();
  68.             case B:
  69.                 return new ProductB();
  70.             default:
  71.                 return null;
  72.         }
  73.     }
  74. }
  76. /**
  77.  * 工厂2
  78.  * 可以生产产品A也可以生产产品B
  79.  */
  80. class FactryMeathod2 implements FactryMeathod {
  81.     /**
  82.      * 根据参数创建相应的产品
  83.      *
  84.      * @param productType 产品类型
  85.      * @return 具体的产品 Product
  86.      */
  87.     @Override
  88.     public Product makeProduct(ProductType productType) {
  89.         switch (productType) {
  90.             case A:
  91.                 return new ProductA();
  92.             case B:
  93.                 return new ProductB();
  94.             default:
  95.                 return null;
  96.         }
  97.     }
  98. }
  100. //工厂方法测试
  101. public class FactoryMethodPattern {
  102.     public static void main(String[] args) {
  103.         FactryMeathod f1 = new FactryMeathod1();
  104.         Product a1 = f1.makeProduct(ProductType.A);
  105.         Product b1 = f1.makeProduct(ProductType.B);
  106.         System.out.println(a1);
  107.         System.out.println(b1);
  109.         //此时增加需求，我只需增加一个新的工厂实现FactryMeathod2 即可，无需修改FactryMeathod1
  110.         FactryMeathod f2 = new FactryMeathod2();
  111.         Product a2 = f2.makeProduct(ProductType.A);
  112.         Product b2 = f2.makeProduct(ProductType.B);
  113.         System.out.println(a2);
  114.         System.out.println(b2);
  116.     }
  117. }

JDK中的工厂方法模式

Collection中的iterator方法
java.util.Collection接口中定义了一个抽象的iterator()方法，该方法就是一个工厂方法。
对于iterator()方法来说Collection就是一个根抽象工厂，下面还有List等接口作为抽象工厂，再往下有ArrayList等具体工厂。
java.util.Iterator接口是根抽象产品，下面有ListIterator等抽象产品，还有ArrayListIterator等作为具体产品。
JDBC也是工厂方法模式
在使用JDBC进行数据库开发时，如果数据库由MySQL改为Oracle或其他，则只需要改一下数据库驱动名称就可以，其他都不用修改。

抽象工厂模式 Abstract Factory Pattern

抽象工厂类比现实中的集团，有一个超级工厂可以创建其他工厂，由其他工厂在创建具体的产品。比如海尔，海尔旗下有多个品牌，比如卡萨帝和统帅
卡萨帝可以生产空调、冰箱、洗衣机
统帅也可以生产空调、冰箱、洗衣机

代码实现

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（ProductA，ProductB）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
  • 抽象工厂（Abstract Factory）：超级工厂，用于创建具体的工厂
  • 具体工厂（Factory1，Factory2）：完成具体产品的创建。 ```java /**
    • 产品 */ interface Product { }

/**

  • 产品A */ class ProductA implements Product { }

/**

  • 产品B */ class ProductB implements Product { }

/**

  • 产品类型 */ enum ProductType { //产品A A, //产品B B; }

/**

  • 工厂类型 */ enum FactoryType { //工厂1 f1, //工厂2 f2; }

/**

  • 工厂接口 */ interface Factry { //生产产品抽象方法 Product makeProduct(ProductType productType); }

/**

  • 工厂1
  • 可以生产产品A也可以生产产品B / class Factry1 implements Factry { /*
    • 根据参数创建相应的产品 *
    • @param productType 产品类型
    • @return 具体的产品 Product */ @Override public Product makeProduct(ProductType productType) { switch (productType) {
      1.  case A:
      2.      return new ProductA();
      3.  case B:
      4.      return new ProductB();
      5.  default:
      6.      return null;
      } } }

/**

  • 工厂2
  • 可以生产产品A也可以生产产品B / class Factry2 implements Factry { /*
    • 根据参数创建相应的产品 *
    • @param productType 产品类型
    • @return 具体的产品 Product */ @Override public Product makeProduct(ProductType productType) { switch (productType) {
      1.  case A:
      2.      return new ProductA();
      3.  case B:
      4.      return new ProductB();
      5.  default:
      6.      return null;
      } } }

/**

  • 抽象工厂 */ class AbstractFactory { //创建工厂方法 public static Factry createFactory(FactoryType factoryType) {
    1.  switch (factoryType) {
    2.      case f1:
    3.          return new Factry1();
    4.      case f2:
    5.          return new Factry2();
    6.      default:
    7.          throw new RuntimeException("工厂类型不正确");
    8.  }
    } }

//抽象工厂模式测试 public class FactoryMethodPattern { public static void main(String[] args) { Factry f1 = AbstractFactory.createFactory(FactoryType.f1); Product a1 = f1.makeProduct(ProductType.A); Product b1 = f1.makeProduct(ProductType.B); System.out.println(a1); System.out.println(b1);

  1.     Factry f2 = AbstractFactory.createFactory(FactoryType.f2);
  2.     Product a2 = f2.makeProduct(ProductType.A);
  3.     Product b2 = f2.makeProduct(ProductType.B);
  4.     System.out.println(a2);
  5.     System.out.println(b2);
  7. }

}

```

JDK中抽象工厂模式

Calendar类的getInstance()方法就是抽象工厂应用的绝佳例子