Java 2.工厂模式学习

工厂模式

• 作用：
  实现了创建者和调用者的分离（即调用只是调用，创建只是创建）

• 详细分类：

  1. 简单工厂模式
  2. 工厂方法模式
  3. 抽象工厂模式

• 核心本质：
  实例化对象不使用new，用工厂方法代替；
  将选择实现类，创建对象统一管理和控制。从而将调用者跟实现类解耦合。

• 三种模式：

  1. 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需求扩展已有的代码）
  2. 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
  3. 抽象工厂模式：围绕一个超级工厂创建其他工厂。（该超级工厂又称为其他工厂的工厂）

简单工厂模式

1.模式结构图

2.模式的结构

• 具体工厂（ConcreteFactory）：主要是完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来完成创建

3.模式的实现

• 抽象产品类：

  /**
   * 汽车抽象产品类 
   */
  public interface Car {
      void getCar();
  }
  

• ​ 具体产品类：

  /**
   * 汽车具体产品类：大众牌汽车 
   */
  public class DaZhong implements Car {
      @Override
      public void getCar() {
          System.out.println("大众");
      }
  }
  
  /* *************分割线************* */		
  
  /**
   * 汽车具体产品类：特斯拉牌汽车 
   */
  public class Tesla implements Car {
      public void getCar() {
          System.out.println("特斯拉");
      }
  }
  
  /* *************分割线************* */	
  
  /**
   * 汽车具体产品类：五菱宏光牌汽车 
   */
  public class WuLing implements Car {
      public void getCar() {
          System.out.println("五菱宏光");
      }
  }
  
  

• 具体工厂类：

  /**
   * 简单工厂模式（静态工厂模式）： 
   *	 1.违背了开闭原则
   */
  public class CarFactory {
  
      /**
       * 方式一
       * 如果需要新增车辆品牌，就需要改动getCar方法才能实现新增
       *
       * @param carName
       * @return
       */
      public static Car getCar(String carName) {
          Car car = null;
          switch (carName) {
              case "五菱宏光":
                  car = new WuLing();
                  break;
              case "特斯拉":
                  car = new Tesla();
                  break;
          }
          return car;
      }
  
    // -------------------------------------------
  
      /**
       *  方式二不要改动原有方法，但是需要改动原有类
       */
      public static WuLing getWuLin() {
          return new WuLing();
      }
  
      public static Tesla getTesla() {
          return new Tesla();
      }
  
      /**
       * 工厂 新增大众品牌
       *
       * @return
       */
      public static DaZhong getDaZhong() {
          return new DaZhong();
      }
  
  }
  

• 测试结果：

    /**
    	* 使用静态工厂方法：方式一
     	*/
     	@Test
     	public void testStaticFactor(){
         Car car1 = CarFactory.getCar("五菱宏光");
         Car car2 = CarFactory.getCar("特斯拉");
         Car car3 = CarFactory.getCar("大众");
  
         car1.getCar();
         car2.getCar();
         car3.getCar();
      }
  
      /**
           * 使用静态工厂方法：方式二
           */
      @Test
      public void testStaticFactor2(){
          Car wuLin = CarFactory.getWuLin();
          Car tesla = CarFactory.getTesla();
          Car daZhong = CarFactory.getDaZhong();
          wuLin.getCar();
          tesla.getCar();
          daZhong.getCar();
      }
   /*================= 输出结果================
   	五菱宏光
  	特斯拉
  	大众
     ================= 输出结果================*/
  

工厂方法模式

1.模式结构图

2.模式的结构

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。

• 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

3.模式的实现

• 抽象工厂：

/**
 * 抽象工厂
 */
public interface CarFactory {
    Car getCar();
}

• 具体工厂：

/**
 * 具体工厂：大众牌工厂类
 */
public class DaZhongFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new DaZhong();
    }
}

  /* *************分割线************* */
/**
 * 具体工厂：特斯拉牌工厂类
 */
public class TeslaFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

 /* *************分割线************* */
/**
 * 具体工厂：五菱宏光牌工厂类
 */	
public class WulingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

• 抽象产品：

/**
 *  汽车类
 */
public interface Car {
    void getCar();
}

• 具体产品：

/**
 *  大众汽车
 */
public class DaZhong implements Car {
    @Override
    public void getCar() {
        System.out.println("大众");
    }
}

  /* *************分割线************* */

/**
 * 特斯拉汽车
 */
public class Tesla implements Car {
    public void getCar() {
        System.out.println("特斯拉");
    }
}

  /* *************分割线************* */
  
/**
 * 五菱宏光汽车
 */
public class WuLing implements Car {
    public void getCar() {
        System.out.println("五菱宏光");
    }
}

• 测试结果：

 public static void main(String[] args) {
     CarFactory daZhongFactory = new DaZhongFactory();
     CarFactory teslaFactory = new TeslaFactory();
     CarFactory wulingFactory = new WulingFactory();
 
     Car car = daZhongFactory.getCar();
     Car car1 = teslaFactory.getCar();
     Car car2 = wulingFactory.getCar();
 
     car.getCar();
     car1.getCar();
     car2.getCar();
 }
  /*================= 输出结果================
  	大众
   特斯拉
   五菱宏光
    ================= 输出结果================*/

小结

1. 简单工厂模式（静态工厂模式）:虽然某种程度上不符合设计原则，但实际使用最多！
2. 工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。
3. 抽象工厂模式：不可以增加产品，可以增加产品族！

应用场景

1. JDK中的Calendar的getInstance方法
2. JDBC中的Connection对象的获取
3. Spring中IOC容器创建管理bean对象
4. 反射中Class对象的newInstance方法

简单工厂模式和工厂方法模式 对比

1. 结构复杂度：简单工厂模式 < 工厂方法模式
2. 代码复杂度：简单工厂模式 < 工厂方法模式
3. 编程复杂度：简单工厂模式 < 工厂方法模式
4. 管理复杂度：简单工厂模式 < 工厂方法模式

结论：
根据设计原则：应该使用工厂方法模式
根据实际业务：应该使用简单工厂模式（实际中也是使用简单工厂模式偏多）