简介

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的

工厂模式可以分为三类：

  1. 简单工厂模式（Simple Factory）
  2. 工厂方法模式（Factory Method）
  3. 抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

  1.    将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。

简单工厂

例子

建立一个工厂（一个函数或一个类方法）来制造新的对象。
分布说明引子：从无到有。客户自己创建宝马车，然后拿来用。

  1. public class BMW320 {
  2.     public BMW320(){
  3.         System.out.println("制造-->BMW320");
  4.     }
  5. }
  7. public class BMW523 {
  8.     public BMW523(){
  9.         System.out.println("制造-->BMW523");
  10.     }
  11. }
  13. public class Customer {
  14.     public static void main(String[] args) {
  15.         BMW320 bmw320 = new BMW320();
  16.         BMW523 bmw523 = new BMW523();
  17.     }
  18. }

客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

UML图

我们建立一个工厂类方法来制造新的对象。如图：

简单工厂与工厂方法 - 图1

产品类

  1. abstract class BMW {
  2.     public BMW() { }
  3. }
  5. class BMW320 extends BMW {
  6.     public BMW320() {
  7.         System.out.println("制造320");
  8.     }
  9. }
  11. class BMW523 extends BMW {
  12.     public BMW523() {
  13.         System.out.println("制造523");
  14.     }
  15. }

工厂类

  1. class FactoryBMW {
  2.     public BMW createBMW(int type) {
  3.         switch (type) {
  4.             case 320:
  5.                 return new BMW320();
  6.             case 523:
  7.                 return new BMW523();
  8.             default:
  9.                 break;
  10.         }
  11.         return null;
  12.     }
  13. }

客户类

  1. class Customer {
  2.     public static void main(String[] args) {
  3.         FactoryBMW factoryBMW = new FactoryBMW();
  4.         factoryBMW.createBMW(320);
  5.     }
  6. }

总结

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 

  1.  先来看看它的组成： <br />        1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品<br />        2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         <br />        3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现

但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的

于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。

工厂方法

产品类

  1. abstract class BMW {
  2.     public BMW() { }
  3. }
  5. class BMW320 extends BMW {
  6.     public BMW320() {
  7.         System.out.println("制造320");
  8.     }
  9. }
  11. class BMW523 extends BMW {
  12.     public BMW523() {
  13.         System.out.println("制造523");
  14.     }
  15. }

创建工厂类

  1. interface FactoryBMW {
  2.     BMW createBMW();
  3. }
  5. class FactoryBMW523 implements FactoryBMW {
  7.     @Override
  8.     public BMW createBMW() {
  9.         return new BMW523();
  10.     }
  11. }
  13. class FactoryBMW320 implements FactoryBMW {
  15.     @Override
  16.     public BMW createBMW() {
  17.         return new BMW320();
  18.     }
  19. }

客户类

  1. class Customer {
  2.     public static void main(String[] args) {
  3.         FactoryBMW320 factoryBMW320 = new FactoryBMW320();
  4.         BMW320 bmw320 = (BMW320) factoryBMW320.createBMW();
  6.         FactoryBMW523 factoryBMW523 = new FactoryBMW523();
  7.         BMW523 bmw523 = (BMW523) factoryBMW523.createBMW();
  9.     }
  10. }