简单工厂模式（Simple Factory）

1.简单工厂模式（Simple Factory）

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

还没有工厂时代，假如还没有工业革命，如果一个客户要一款宝马车，一般的做法是客户去创建一款宝马车，然后拿来用。

简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马，想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。

建立一个工厂（一个函数或一个类方法）来制造新的对象。

分布说明引子：从无到有。客户自己创建宝马车，然后拿来用。

 

package com.njwb.common;

/**

 * 3类  2个汽车类BMW320，BMW523  1个客户类 自己去创建汽车对象，想要什么车，就去生产什么。

 * 问题：效率低下, BMW320,BMW523都是汽车，至少应该抽取公共的父类 ，如果有一个工厂类出现，工厂帮助创建，效率会提高，只需要告诉工厂，客户想要的型号就可以了

 * @author Administrator

 *

 */

class BMW320{

public BMW320() {

System.out.println("制造了---BMW320");

}

}

class BMW523{

public BMW523() {

System.out.println("制造了---BMW523");

}

}

/**

 * 客户类

 * @author Administrator

 *

 */

public class Customer {

public void createBMW320(){

BMW320 bmw = new BMW320();

}

public void createBMW523(){

BMW523 bmw = new BMW523();

}

public static void main(String[] args) {

Customer cus = new Customer();

cus.createBMW320();

cus.createBMW523();

}

}

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

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

 

package com.njwb.simplefactory;

/**

 * 简单工厂模式：抽象产品角色（产品的父类） ，具体产品角色（产品的子类），工厂角色(工厂类)

 * 1个产品的父类  2个产品的子类   1个工厂类（复制生产所有的产品子类）  客户类

 * 问题： 如果新增其他的子类，那么工厂类createBMW()方法，需要新增case(增加几个子类，就需要增几个case ),这样工厂类的压力就会非常大，违背开闭原则.

 */

/**

 * 产品的父类

 * @author Administrator

 *

 */

abstract class BMW{

public BMW() {

}

}

/**

 * 2个 具体的产品子类

 * @author Administrator

 *

 */

class BMW320 extends BMW{

public BMW320() {

System.out.println("制造了---BMW320");

}

}

 

class BMW523 extends BMW{

public BMW523() {

System.out.println("制造了---BMW523");

}

}

/**

 * 工厂类

 * @author Administrator

 *

 */

class FactoryBMW{

/**

 * 从方法来看，父类做返回值,根据传入的参数，new具体的子类对象出来

 * @param type

 * @return

 */

public BMW createBMW(int type){

BMW bmw = null;

switch(type){

case 320:

bmw = new BMW320();

break;

case 523:

bmw = new BMW523();

break;

}

return bmw;

}

}

public class Customer {

public static void main(String[] args) {

//实例化工厂类 的对象

FactoryBMW fac = new FactoryBMW();

//传入具体的型号，就可以借助工厂类提供的方法，获取想要的产品了

BMW bm1 = fac.createBMW(320);

BMW bm2 = fac.createBMW(523);

}

}

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

先来看看它的组成：

1）工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

2）抽象产品角色：它一般是具体产品继承的父类或者实现的接口。

3）具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

下面我们从开闭原则（对外开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类里增加相应的创建业务逻辑（createBMW(int type)方法需要新增case）,这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。

我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。

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

2.工厂方法模式(Factory Method)

工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要制定某个具体的工厂才能生产车出来。

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

工厂方法模式组成：

1）抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或接口来实现。

2）具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3）抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般由抽象类或者接口来实现。

4）具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力(减轻了简单工厂模式中工厂类的压力)；而且这样使得结构变得灵活起来—当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的。

package com.njwb.methodfactory;

/**

 * 工厂方法模式 ：  抽象产品角色(产品的父类)   具体产品角色（产品的子类）   

 * 1个抽象产品，多个具体产品 ，1个抽象工厂，多个具体的子工厂 ，1个子工厂生产1样具体产品

 *

 * 抽象工厂角色（工厂的父类，或者是父接口）  具体工厂角色（工厂的子类，子工厂， 父接口的具体的实现类）

 * 已经符合开闭原则，如果新增其他类型的宝马车，只需要新增子类extends BMW{}新增子工厂类 FacBMWXXX implement FactoryBMW{....}

 * 问题： 如果有大量的产品子类出现，那么按这种模式生产，就会出现大量的工厂子类。

 * 引出了抽象工厂模式，之前是生产产品子类，现在是生产产品子类需要的配件，假设车由发动机和空调组成，发动机的型号为A,B,空调的型号分为A,B

 * 配件可以自由组合成子类需要的

 * BMW320 ：发动机A,空调A

 * BMW523：发动机B,空调B

 * BMW535：发动机A,空调B

 * BMW330:发动机B,空调A

 * @author Administrator

 *

 */

/**

 * 抽象产品角色

 */

abstract class BMW{

public BMW() {

}

}

/**

 * 2个产品的子类 ---具体的产品角色

 * @author Administrator

 *

 */

class BMW320 extends BMW{

public BMW320() {

System.out.println("制造了---BMW320");

}

}

 

class BMW523 extends BMW{

public BMW523() {

System.out.println("制造了---BMW523");

}

}

/**

 * 抽象工厂角色

 * @author Administrator

 *

 */

interface FactoryBMW{

//生产宝马车

BMW createBMW();

}

/**

 * 具体的子工厂（父接口的实现类）,1个子工厂只生产1个产品子类

 * @author Administrator

 *

 */

class FactoryBMW320 implements FactoryBMW{

@Override

public BMW createBMW() {

return new BMW320();

}

}

class FactoryBMW523 implements FactoryBMW{

@Override

public BMW createBMW() {

return new BMW523();

}

}

public class Customer {

public static void main(String[] args) {

//生产320系列的

FactoryBMW320 fac = new FactoryBMW320();

BMW bm1 = fac.createBMW();

//生产523系列的

FactoryBMW523 fac2 = new FactoryBMW523();

BMW bm2 = fac2.createBMW();

}

}

3.抽象工厂模式(Abstract Factory)

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调宝马车。

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method） 与抽象工厂模式（Abstract Facoty）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

例子背景：

随着客户的要求越来越高，宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机，用来组装汽车。这时候工厂有两个系列的产品：空调和发动机。宝马320系列配置A型号空调和A型号发动机，宝马523系列配置B型号空调和B型号发动机。

概念：

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。比如宝马320系列使用空调型号A和发动机型号A,而宝马230系列使用空调型号B和发动机型号B,那么使用抽象工厂模式，在为320系列生产相关配件时，就无需指定配件的型号，它会自动根据车型生产对应的配件型号A.

当每个抽象产品都有多于一个的具体子类的时候（空调有型号A和B两种，发动机也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品空调有两个具体产品空调A和空调B）。抽象工厂模式提供两个具体工厂角色（宝马320系列工厂和宝马230系列工厂），分别对应于这2个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

package com.njwb.abstractfactory;

/**

 * 本例中

 * 2个抽象产品父类 ，每一个抽象产品父类，对应2个具体产品子类

 * 1个抽象工厂，有2个具体工厂 ，每个工厂生产2个配件

 * 抽象工厂模式： 多个抽象产品父类，每一个抽象产品父类，对应多个具体产品子类

 * 1个抽象工厂类，多个具体工厂类 ，每个具体工厂都可以生产多个具体产品

 * @author Administrator

 *

 */

/**

 * 抽象产品  产品的父类

 */

abstract class AirCondition{

public AirCondition() {

}

}

/**

 * 具体的产品子类

 * @author Administrator

 *

 */

class AirConditionA extends AirCondition{

public AirConditionA() {

System.out.println("生产--->空调A");

}

}

 

class AirConditionB extends AirCondition{

public AirConditionB() {

System.out.println("生产--->空调B");

}

}

/**

 * 抽象产品角色

 * @author Administrator

 *

 */

abstract class Engine{

public Engine() {

}

}

/**

 * 2个具体的产品角色（产品的子类）

 * @author Administrator

 *

 */

class EngineA extends Engine{

public EngineA() {

System.out.println("生产--->发动机A");

}

}

class EngineB extends Engine{

public EngineB() {

System.out.println("生产--->发动机B");

}

}

/**

 * 抽象工厂角色 提供2个抽象方法，用于生产配置

 * @author Administrator

 *

 */

interface FactoryBMW{

Engine createEngine();

AirCondition createAirCondition();

}

/**

 * 具体工厂角色，每个具体工厂都可以生产多个配件

 * @author Administrator

 *

 */

class FactoryBMW1 implements FactoryBMW{

@Override

public AirCondition createAirCondition() {

return new AirConditionA();

}

@Override

public Engine createEngine() {

return new EngineA();

}

}

class FactoryBMW2 implements FactoryBMW{

@Override

public AirCondition createAirCondition() {

return new AirConditionB();

}

@Override

public Engine createEngine() {

return new EngineB();

}

}

public class Customer {

public static void main(String[] args) {

//假如BMW320需要发动机A,空调A ,生产需要的配件,调用具体工厂子类1

FactoryBMW1 fac1 = new FactoryBMW1();

AirCondition con1 = fac1.createAirCondition();

Engine en = fac1.createEngine();

//生产BMW523的配件 ，子工厂2可以生产出523需要的配件

FactoryBMW2 fac2 = new FactoryBMW2();

AirCondition con2 = fac2.createAirCondition();

Engine en2 = fac2.createEngine();

}

}

4.区别

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

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