—-慢慢来比较快，虚心学技术—-

概念

属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

实质上，简单工厂就是通过传参的形式在工厂类中根据类型去创建相应的具体产品（if…else）

推演

反例

  1. /**
  2.  * @description 简单工厂模式反例
  3.  * @auther: 
  4.  * @date: 2019-09-25 22:45
  5.  */
  6. public class Negative {
  7.     public static void main(String[] args) {
  8.         /**
  9.          * 这种设计模式非常脆弱，只要服务器端代码一旦发生更改，则客户端代码必须随之改变，否则出现异常
  10.          * 如将Hamburger类改为Hamburger2，则下述代码也要相应改变
  11.          * 客户端必须知道接口Food的具体细节，违反了迪米特法则
  12.          */
  13.         Food food = new Hamburger();
  14.         food.eat();
  15.     }
  16. }
  17. //======================服务端=======================//
  18. /**
  19.  * 接口类,抽象产品
  20.  */
  21. interface Food{
  22.     void eat();
  23. }
  24. /**
  25.  *  实现类，具体产品
  26.  */
  27. class Hamburger implements  Food{
  28.     @Override
  29.     public void eat() {
  30.         System.out.println("吃汉堡包");
  31.     }
  32. }

正例

  1. /**
  2.  * @description  简单工厂模式正例
  3.  * @auther: 
  4.  * @date: 2019-09-25 22:53
  5.  */
  6. public class Positive {
  7.     public static void main(String[] args) {
  8.         /**
  9.          * 解决反例中的问题，创建工厂，客户端仅需要知道通过工厂获取具体对象的代号或序号，而不需要知道具体的对象细节
  10.          * 即便服务端作者将Hamburger的名字改变了，也仅需要在服务器将1对应的new Hamburger()同步更改，而客户端并不会感知该变化
  11.          */
  12.         Food food = FoodFactory.getFood(1);
  13.         food.eat();
  14.     }
  15. }
  16. //======================服务端=======================//
  17. /**
  18.  * 简单工厂类，用于生产Food对象
  19.  */
  20. class FoodFactory{
  21.     public static Food getFood(int n){
  22.         Food food = null;
  23.         switch (n){
  24.             case 1:
  25.                 food = new Hamburger();
  26.                 break;
  27.             case 2:
  28.                 food = new Noodle();
  29.                 break;
  30.         }
  31.         return food;
  32.     }
  33. }
  34. /**
  35.  * 接口类,抽象产品
  36.  */
  37. interface Food{
  38.     void eat();
  39. }
  40. /**
  41.  *  实现类，具体产品
  42.  */
  43. class Hamburger implements Food {
  44.     @Override
  45.     public void eat() {
  46.         System.out.println("吃汉堡包");
  47.     }
  48. }
  49. class Noodle implements Food {
  50.     @Override
  51.     public void eat() {
  52.         System.out.println("吃面条");
  53.     }
  54. }

应用场景

1、工厂类负责创建的对象比较少；
2、客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

主要是业务非常简单的情况下使用

优点

把具体产品的类型，从客户端代码中**解耦**出来。客户端不需要关注创建对象的部分，去除了与具体产品的依赖

缺点


1、客户端需要死记硬背那些常量与具体产品的映射关系，如上述的1：汉堡包，2：面条
2、如果具体产品过多，将会导致工厂类的代码臃肿
3、最重要的一点，如果客户端需要扩展具体产品如新增一个具体产品时，将不得不同时更改服务端工厂类代码，违反了“开闭原则”**

简单工厂死于扩展！！！！

如有贻误，还请评论指正