「这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战」

工厂设计模式

1.什么是工厂设计模式

工厂设计模式，顾名思义，就是用来生产对象的。

1.工厂设计模式是把对象的使用和创建分开的一种设计模式，使得使用者只需关心如何使用类，而不用关心该类的创建过程，降低对象之间的耦合，方便扩展。

2.在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，大大降低了程序的耦合性。

3.工厂模式的意义主要将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，提高项目的扩展和维护性。

2.为什么需要工厂设计模式

2.1 简单例子

开发一个关于披萨的项目：要便于披萨种类的扩展，要便于维护，要求如下：

披萨的种类很多(比如 GreekPizz、CheesePizz 等)
披萨的制作过程有 prepare(准备)，bake(烘烤), cut(切块), box(装盒）
完成披萨店订购功能（以下订购方法均放在order（）中，order()用于生产pizza)

2.2 使用传统的方法

1.uml类图

图片.png

2.定义一个Pizza类里面写有，prepare(),bake(),cut(),box()四个方法，然后根据不同的种类的pizza都去继承这个类，或者重写一下它的方法。在传统模式中，假设我们类的创建和使用不分开，调用order()方法生产pizza。那我们的生产pizza的代码，则需要在业务代码中进行判断。如下：

Pizza pizza = null;

if (orderType.equals("greek")) {
   pizza = new GreekPizza();
   pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
   pizza = new CheesePizza();
   pizza.setName(" 奶酪披萨 ");
} 
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();

这是传统模式中生产pizza的过程，当我们新增一个胡椒披萨时，代码则需要在下面再加一个else if 判断，

Pizza pizza = null;

if (orderType.equals("greek")) {
   pizza = new GreekPizza();
   pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
   pizza = new CheesePizza();
   pizza.setName(" 奶酪披萨 ");
} 

else if (orderType.equals("pepper")) {
   pizza = new PepperPizza();
   pizza.setName("胡椒披萨");
} 

//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();

这种写法，每当有一个新的种类pizza ,我们都需要在所有生产pizza的地方多加一层判断！而通常会有很多地方使用这个方法，这种写法严重违反了 ocp原则！

ocp原则：

一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

3.简单工厂模式

3.1 uml类图

图片.png

这里我们生产pizza。通过simpleFactory给我们提供的创建pizza方法即可，以后有扩展也只要修改这一处。

3.2 定义一个工厂类对象，专门用来生产pizza,我们只需要传入一个参数，根据参数获取返回值结果即可，即把对象创建方法单独给抽取出来，使用者无需关心具体创建细节。

public static Pizza createPizza(String orderType) {

   Pizza pizza = null;

   System.out.println("使用简单工厂模式2");
   if (orderType.equals("greek")) {
      pizza = new GreekPizza();
      pizza.setName(" 希腊披萨 ");
   } else if (orderType.equals("cheese")) {
      pizza = new CheesePizza();
      pizza.setName(" 奶酪披萨 ");
   } else if (orderType.equals("pepper")) {
      pizza = new PepperPizza();
      pizza.setName("胡椒披萨");
   }
   
   return pizza;
}

3.3 总结

简单工厂模式，是工厂模式中使用最简单实用的一种设计模式，它帮我们封装某个类实例化的代码，使得类的使用和创建这两个过程是分离的。在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

4.工厂方法模式

4.1 uml类图

图片.png

4.2 原理

工厂方法模式是在，简单工厂模式上的进一步抽象，即把生产对象的工厂类，也给它抽象出来，具体实现细节交给子类完成。比如在简单工厂类中prepare(准备)，bake(烘烤), cut(切块), box(装盒）实现方式是一样的，而在工厂方法模式中，我们可以自定义继承抽象工厂的工厂类，在不同的工厂实现类中实现这些prepare(准备)，bake(烘烤), cut(切块), box(装盒）方法的不同细节。

4.3实现

1.把原先的工厂类的创建方法给抽象出来，具体实现交给子类

public abstract class OrderPizza {

   //定义一个抽象方法，createPizza , 让各个工厂子类自己实现
   abstract Pizza createPizza(String orderType);

   // 构造器
   public Pizza OrderPizza(String type) {
      Pizza pizza = null;
      pizza = createPizza(type); //抽象方法，由工厂子类完成
      //输出pizza 制作过程
      pizza.prepare();
      pizza.bake();
      pizza.cut();
      pizza.box();

      return pizza;
   }

}

2.具体实现子类

LDOrderPizza pizza生产工厂

public class LDOrderPizza extends OrderPizza {

   
   @Override
   Pizza createPizza(String orderType) {
   
      Pizza pizza = null;
      if(orderType.equals("cheese")) {
         pizza = new LDCheesePizza();
      } else if (orderType.equals("pepper")) {
         pizza = new LDPepperPizza();
      }
      // TODO Auto-generated method stub
      return pizza;
   }

}

BJOrderPizza pizza生产工厂

public class BJOrderPizza extends OrderPizza {

   
   @Override
   Pizza createPizza(String orderType) {
   
      Pizza pizza = null;
      if(orderType.equals("cheese")) {
         pizza = new BJCheesePizza();
      } else if (orderType.equals("pepper")) {
         pizza = new BJPepperPizza();
      }
      // TODO Auto-generated method stub
      return pizza;
   }

}

调用方式需自己选择对应的工厂子类

public static void main(String[] args) {
   String loc = "bj";
   if (loc.equals("bj")) {
      //创建北京口味的各种Pizza
      new BJOrderPizza();
   } else {
      //创建伦敦口味的各种Pizza
      new LDOrderPizza();
   }
}

以上可以发现，对于同一种pizza ,我们在不同的生产工厂中，可以自定义不同的实现细节。(ps:如CheesePizza，在BJOrderPizza 中生产的是 BJCheesePizza，在LDOrderPizza 中生产的是 LDCheesePizza，不同工厂中可以生产不同的CheesePizza ) 对于新增的工厂类，大家只需要在该工厂类中重写createPizza()方法即可。

5.抽象工厂类

5.1 uml 类图

图片.png

5.2原理

抽象工厂模式，从设计层面上看就是对简单工厂模式和工厂方法模式的进一步整合，把原先的工厂类给抽象成两层，工厂抽象类和具体的实现子类。我们在调用时无像向抽象方法模式中自己选择对应的工厂子类，我们以抽象工厂类作为形参，在调用时传入其具体实现子类即可。

抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

5.3代码

抽象工厂类

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
   //让下面的工厂子类来 具体实现
   public Pizza createPizza(String orderType);
}

抽象工厂子类

public class BJFactory implements AbsFactory {

  @Override
  public Pizza createPizza(String orderType) {
     System.out.println("~使用的是抽象工厂模式~");
     // TODO Auto-generated method stub
     Pizza pizza = null;
     if(orderType.equals("cheese")) {
        pizza = new BJCheesePizza();
     } else if (orderType.equals("pepper")){
        pizza = new BJPepperPizza();
     }
     return pizza;
  }

}

public class LDFactory implements AbsFactory {

   @Override
   public Pizza createPizza(String orderType) {
      System.out.println("~使用的是抽象工厂模式~");
      Pizza pizza = null;
      if (orderType.equals("cheese")) {
         pizza = new LDCheesePizza();
      } else if (orderType.equals("pepper")) {
         pizza = new LDPepperPizza();
      }
      return pizza;
   }

}

3.调用方式

public class OrderPizza {

   AbsFactory factory;

   // 构造器
   public OrderPizza(AbsFactory factory) {
      setFactory(factory);
   }

   private Pizza setFactory(AbsFactory factory) {
      Pizza pizza = null;
      String orderType = ""; // 用户输入
      this.factory = factory;

      orderType = getType();
      // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
      pizza = factory.createPizza(orderType);
      if (pizza != null) { // 订购ok
         pizza.prepare();
         pizza.bake();
         pizza.cut();
         pizza.box();
      }
      return pizza;
   }

}


public static void main(String[] args) {
   // TODO Auto-generated method stub
   //new OrderPizza(new BJFactory());
   new OrderPizza(new LDFactory());
}

6.应用案例

6.1 java.util.Calendar

// 获取Calendar 对象实例
public static Calendar getInstance(TimeZone zone,
                                   Locale aLocale)
{
    return createCalendar(zone, aLocale);
}

private static Calendar createCalendar(TimeZone zone,
                                       Locale aLocale)
{
    //抽象工厂类
    CalendarProvider provider =
        LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                             .getCalendarProvider();
    
    if (provider != null) {
        try {
            return provider.getInstance(zone, aLocale); //这里是默认获取方式，
        } catch (IllegalArgumentException iae) {
            // fall back to the default instantiation
        }
    }

CalendarProvider 类源码

public abstract class CalendarProvider extends LocaleServiceProvider {
    protected CalendarProvider() {
    }

    public abstract Calendar getInstance(TimeZone var1, Locale var2);
}

下面是具体实现子类

图片.png

7总结

工厂模式的意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的

依赖关系的解耦。从而提高项目的扩展和维护性。

三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
设计模式的依赖抽象原则
- 创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
- 不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
- 不要覆盖基类中已经实现的方法

java设计模式 --- 工厂模式

工厂设计模式

1.什么是工厂设计模式

2.为什么需要工厂设计模式

2.1 简单例子

2.2 使用传统的方法

3.简单工厂模式

3.1 uml类图

3.2 定义一个工厂类对象，专门用来生产pizza,我们只需要传入一个参数，根据参数获取返回值结果即可，即把对象创建方法 单独给抽取出来，使用者无需关心具体创建细节。

3.3 总结

4.工厂方法模式

4.1 uml类图

4.2 原理

4.3实现

5.抽象工厂类

5.1 uml 类图

5.2原理

5.3代码

6.应用案例

6.1 java.util.Calendar

7总结

3.2 定义一个工厂类对象，专门用来生产pizza,我们只需要传入一个参数，根据参数获取返回值结果即可，即把对象创建方法单独给抽取出来，使用者无需关心具体创建细节。