创建型设计模式 - 工厂

23种设计模式，分三大类，创建型、结构型、行为型。
创建型总共有 5 个，分两次记，第一次关注工厂。

• 工厂模式（factory），是在还没有工厂时，讨论如何开工厂(定义类)，生产产品(产生类的对象)

1、工厂模式（FactoryMethod）

分为简单工厂方法和工厂方法两个模式

1.1、简单工厂

• 只有一个工厂，一个工厂可生产多种产品
• 对于这些产品，一个工厂可以应付

步骤：

• 创建各个产品接口、以及产品类

  public interface IProduct {}
  

  public class Product_A implements IProduct {}
  //public class Product_B implements IProduct {}
  

• 创建一个工厂对象，根据参数创建不同的产品

  public class Factory {
      public IProduct GetProduct(String productName) {
          switch (productName) {
              case "A":
                  return new Product_A();
  			//case "B":
  				//return new Product_B();
              default:
                  return null;
          }
      }
  }
  

• 调用工厂对象，获得产品对象

  public class Test {
      public static void main(String[] args) {
          IProduct product_A = new Factory().GetProduct("A");
          //IProduct product_B = new Factory().GetProduct("B");
      }
  }
  

1.2、工厂方法

• 有多个工厂，每个工厂生产一种产品
• 对于这些产品，一个工厂忙不过来的，可以把产品分给多个工厂来做

步骤：

• 创建各个产品接口、以及产品类

  public interface IProduct {}
  

  public class Product_A implements IProduct {}
  //public class Product_B implements IProduct {}
  

• 创建各个工厂接口、以及工厂类

  public interface IFactory {
      IProduct GetProduct();
  }
  

  public class Factory_A implements IFactory {
      public IProduct GetProduct() {
          return  new Product_A();
      }
  }
  //public class Factory_B implements IFactory {}
  

• 调用不同的工厂类，获得不同的产品对象

  public class Test {
      public static void main(String[] args) {
          IProduct product_A = new Factory_A().GetProduct();
          //Product product_B = new Factory_B().GetProduct();
      }
  }
  

2、抽象工厂（AbstractFactory）

抽象工厂：

• 有多个工厂，每个工厂可生产多种产品
• 对于这些产品，如果按种类分给多个工厂来做，工厂的数量会很多，难管理，可以把产品分类，分给多个工厂来做，我们只需定义一个抽象工厂(标准工厂)，用来约束实际工厂生产的产品

步骤：

• 定义各个产品接口

  public interface IProduct_A {}
  public interface IProduct_B {}
  

• 定义不同工厂生产的产品类

  public class Product_NA implements IProduct_A {}
  //public class Product_NB implements IProduct_B {}
  public class Product_MA implements IProduct_A {}
  //public class Product_MB implements IProduct_B {}
  

• 归类可以集中在一家工厂生产的产品，定义一个抽象工厂接口

  public interface IProductFactory {
      IProduct_A product_A_Factory();
      IProduct_B product_B_Factory();
  }
  

• 定义实际工厂类，用于创建指定产品对象

  public class Factory_N implements IProductFactory {
      public IProduct_A product_A_Factory() {
          return new Product_NA();
      }
      public IProduct_B product_BM_Factory() {
          return new Product_NB();
      }
  }
  //public class Factory_M implements IProductFactory {}
  

• 调用实际工厂对象，获得该工厂生产的产品对象

  public class Test {
      public static void main(String[] args) {
          Factory_N factory_n = new Factory_N();
          IProduct_A product_na = factory_n.product_A_Factory();
          IProduct_B product_nb = factory_n.product_A_Factory();
          
          //Factory_M factory_m = new Factory_M();
          //IProduct_A product_ma = factory_m.product_A_Factory();
      }
  }