Java设计模式GOF之工厂模式

一、工厂模式（Factory）

1、实现了创建者和调用者的分离

2、应用场景
　　①JDK中 Calendar 的 getInstance()；
　　②JDBC 的 Connection 对象的获取；
　　③Hibernate 的 SessionFactory 创建 Session 对象；
　　④Spring 的 IOC 容器创建管理 Bean 对象；
　　⑤XML 的解析时 DocumentBuilderFactory 创建解析器对象；
　　⑥反射中 Class 对象的 newInstance()。

3、分类：
　　①简单工厂模式（也叫静态工厂模式，经常使用）
　　　　1、用来生产同一等级结构中的任意产品；
　　　　2、对于新增的产品，需要修改已有的代码。
　　　　3、不满足开闭原则（对扩展开放，对修改关闭）

　　②工厂方法模式
　　　　1、用来生产同一等级结构中的固定产品；
　　　　2、支持增加任意产品。

　　　　3、支持开闭原则（对扩展开放，对修改关闭）。

　　③抽象工厂模式
　　　　1、用来生产不同产品族的全部产品；
　　　　2、增加新的产品（一个），无能为力；
　　　　3、支持增加产品族。

二、工厂模式的代码实现

1、简单工厂模式

1.1、简单工厂模式产品的接口： Car.java

 1 package cn.com.zfc.gof01.factory.simplefactoy;
 2 
 3 /**
 4 * 
 5 * @title Car
 6 * @describe 简单工厂模式产品的接口 Car
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:44:42
 9 */
10 public interface Car {
11 　　public abstract void run();
12 
13 }

1.2、简单工厂模式产品接口 Car 的实现类： Audi.java

 1 package cn.com.zfc.gof01.factory.simplefactoy;
 2 
 3 /**
 4 * 
 5 * @title Audi
 6 * @describe 简单工厂模式产品接口 Car 的实现类： Audi.java
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Audi implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("奥迪在行驶");
15 　　}
16 
17 }

1.3、简单工厂模式产品接口 Car 的实现类 :Benz.java

 1 package cn.com.zfc.gof01.factory.simplefactoy;
 2 
 3 /**
 4 * 
 5 * @title Benz
 6 * @describe 简单工厂模式产品接口 Car 的实现类： Benz.java
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Benz implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("奔驰在行驶");
15 　　}
16 
17 }

1.4、简单工厂模式产品接口 Car 的实现类：Bmw.java

 1 package cn.com.zfc.gof01.factory.simplefactoy;
 2 
 3 /**
 4 * 
 5 * @title Bmw
 6 * @describe 简单工厂模式产品接口 Car 的实现类 Bmw
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Bmw implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("宝马在行驶");
15 　　}
16 
17 }

1.5、简单工厂模式的工厂类：CarFactory.java

 1 package cn.com.zfc.gof01.factory.simplefactoy;
 2 
 3 /**
 4 * 
 5 * @title CarFactory
 6 * @describe 简单工厂，一般使用静态的方法
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:50:08
 9 */
10 public class CarFactory {
11 
12 　　// 获取 Bmw 的实例
13 　　public static Car getBmw() {
14 　　　　return new Bmw();
15 　　}
16 
17 　　// 获取 Benz 的实例
18 　　public static Car getBenz() {
19 　　　　return new Benz();
20 　　}
21 
22 　　// 获取 Audi 的实例
23 　　public static Car getAudi() {
24 　　　　return new Audi();
25 　　}
26 
27 }

1.6、测试没有工厂类的前提下，创建 Audi、Benz、Bmw：TestNoFactory.java

 1 package cn.com.zfc.gof01.factory.simplefactoy.test;
 2 
 3 import cn.com.zfc.gof01.factory.simplefactoy.Audi;
 4 import cn.com.zfc.gof01.factory.simplefactoy.Benz;
 5 import cn.com.zfc.gof01.factory.simplefactoy.Bmw;
 6 import cn.com.zfc.gof01.factory.simplefactoy.Car;
 7 
 8 /**
 9 * 
10 * @title TestNoFactory
11 * @describe 没有工厂类，创建 Audi、Benz、Bmw
12 * @author 张富昌
13 * @date 2017年4月4日下午8:52:37
14 */
15 public class TestNoFactory {
16 　　public static void main(String[] args) {
17 　　　　// 需要知道接口和其实现类
18 　　　　Car c1 = new Audi();
19 　　　　Car c2 = new Benz();
20 　　　　Car c3 = new Bmw();
21 　　　　c1.run();
22 　　　　c2.run();
23 　　　　c3.run();
24 　　}
25 
26 }

1.7、测试在有工厂类的前提下，创建 Audi、Benz、Bmw：TestSimpleFactory.java

 1 package cn.com.zfc.gof01.factory.simplefactoy.test;
 2 
 3 import cn.com.zfc.gof01.factory.simplefactoy.Car;
 4 import cn.com.zfc.gof01.factory.simplefactoy.CarFactory;
 5 
 6 /**
 7 * 
 8 * @title TestSimpleFactory
 9 * @describe 测试简单工厂模式，有工厂类，创建 Audi、Benz、Bmw
10 * @author 张富昌
11 * @date 2017年4月4日下午8:56:39
12 */
13 public class TestSimpleFactory {
14 　　　public static void main(String[] args) {
15 　　　　// 需要知道接口和工厂类
16 　　　　Car c1 = CarFactory.getAudi();
17 　　　　Car c2 = CarFactory.getBenz();
18 　　　　Car c3 = CarFactory.getBmw();
19 　　　　c1.run();
20 　　　　c2.run();
21 　　　　c3.run();
22 　　}
23 }

2、工厂方法模式

2.1、简单工厂模式产品的接口： Car.java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title Car
 6 * @describe 简单工厂模式产品的接口 Car
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:44:42
 9 */
10 public interface Car {
11 　　public abstract void run();
12 }

2.2、工厂方法模式产品接口 Car 的实现类：Audi.java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title Audi
 6 * @describe 工厂方法模式产品接口 Car 的实现类 Audi
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Audi implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("奥迪在行驶");
15 　　}
16 
17 }

2.3、工厂方法模式产品接口 Car 的实现类 Benz

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title Benz
 6 * @describe 工厂方法模式产品接口 Car 的实现类 ：Benz.java
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Benz implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("奔驰在行驶");
15 　　}
16 
17 }

2.4、工厂方法模式产品接口 Car 的实现类：Bmw.java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title Bmw
 6 * @describe 工厂方法模式产品接口 Car 的实现类 Bmw
 7 * @author 张富昌
 8 * @date 2017年4月4日下午8:45:48
 9 */
10 public class Bmw implements Car {
11 
12 　　@Override
13 　　public void run() {
14 　　　　System.out.println("宝马在行驶");
15 　　}
16 
17 }

2.5、工厂方法模式的工厂接口：CarFactory.java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title CarFactory
 6 * @describe 工厂方法模式的工厂接口 CarFactory
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:05:18
 9 */
10 public interface CarFactory {
11 　　Car getCar();
12 }

2.6、工厂方法模式的工厂类，需要实现工厂接口：AudiFactory .java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title AudiFactory
 6 * @describe 工厂方法模式的工厂类，需要实现工厂接口
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:07:08
 9 */
10 public class AudiFactory implements CarFactory {
11 
12 　　@Override
13 　　public Car getCar() {
14 　　　　return new Audi();
15 　　}
16 
17 }

2.7、工厂方法模式的工厂类，需要实现工厂接口：BenzFactory .java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title BenzFactory
 6 * @describe 工厂方法模式的工厂类，需要实现工厂接口
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:07:08
 9 */
10 public class BenzFactory implements CarFactory {
11 
12 　　@Override
13 　　public Car getCar() {
14 　　　　return new Benz();
15 　　}
16 
17 }

2.8、工厂方法模式的工厂类，需要实现工厂接口：CarFactory .java

 1 package cn.com.zfc.gof01.factory.factorymethod;
 2 
 3 /**
 4 * 
 5 * @title BmwFactory
 6 * @describe 工厂方法模式的工厂类，需要实现工厂接口
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:07:08
 9 */
10 public class BmwFactory implements CarFactory {
11 
12 　　@Override
13 　　public Car getCar() {
14 　　　　return new Bmw();
15 　　}
16 
17 }

2.9、测试工厂方法模式：TestFactoryMethod.java

 1 package cn.com.zfc.gof01.factory.factorymethod.test;
 2 
 3 import cn.com.zfc.gof01.factory.factorymethod.AudiFactory;
 4 import cn.com.zfc.gof01.factory.factorymethod.BenzFactory;
 5 import cn.com.zfc.gof01.factory.factorymethod.BmwFactory;
 6 import cn.com.zfc.gof01.factory.factorymethod.Car;
 7 
 8 /**
 9 * 
10 * @title TestFactoryMethod
11 * @describe 测试工厂方法模式
12 * @author 张富昌
13 * @date 2017年4月4日下午9:09:34
14 */
15 public class TestFactoryMethod {
16 　　public static void main(String[] args) {
17 　　　　// 需要知道接口和各自的工厂类
18 　　　　Car c1 = new AudiFactory().getCar();
19 　　　　Car c2 = new BenzFactory().getCar();
20 　　　　Car c3 = new BmwFactory().getCar();
21 　　　　c1.run();
22 　　　　c2.run();
23 　　　　c3.run();
24 　　}
25 }

3、抽象工厂模式

3.1、抽象工厂的产品接口，发动机：Engine.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title Engine
 6 * @describe 抽象工厂的产品接口，发动机
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:27:21
 9 */
10 public interface Engine {
11 　　// 发动机效率
12 　　void efficiency();
13 }

3.2、抽象接口的产品接口，座位：Seat.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title Seat
 6 * @describe 抽象接口的产品接口，座位
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:38:21
 9 */
10 public interface Seat {
11 　　// 座位舒适
12 　　void comfort();
13 
14 }

3.3、抽象工厂的产品接口，轮胎：Tyre.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title Tyre
 6 * @describe 抽象工厂的产品接口，轮胎
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:39:06
 9 */
10 public interface Tyre {
11 　　// 轮胎磨损
12 　　void wear();
13 }

3.4、抽象工厂模式的产品实现类，低端发动机:LowEngine.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 /**
 3 * 
 4 * @title LowEngine
 5 * @describe 抽象工厂模式的产品实现类，低端发动机
 6 * @author 张富昌
 7 * @date 2017年4月4日下午9:55:02
 8 */
 9 public class LowEngine implements Engine {
10 
11 　　@Override
12 　　public void efficiency() {
13 　　　　System.out.println("低端发动机工作效率低");
14 　　}
15 
16 }

3.5、抽象工厂模式的产品实现类，高端发动机：LuxuryEngine.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title LuxuryEngine
 6 * @describe 抽象工厂模式的产品实现类，高端发动机
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:48:05
 9 */
10 public class LuxuryEngine implements Engine {
11 
12 　　@Override
13 　　public void efficiency() {
14 　　　　System.out.println("高端发动机工作效率高");
15 　　}
16 
17 }

3.6、抽象工厂模式的产品实现类，低端座位：LowSeat.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title LowSeat
 6 * @describe 抽象工厂模式的产品实现类，低端座位
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:55:32
 9 */
10 public class LowSeat implements Seat {
11 
12 　　@Override
13 　　public void comfort() {
14 　　　　System.out.println("低端座位舒适度低");
15 　　}
16 
17 }

3.7、抽象工厂模式的产品实现类，高端座位:LuxurySeat.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 /**
 3 * 
 4 * @title LuxurySeat
 5 * @describe 抽象工厂模式的产品实现类，高端座位
 6 * @author 张富昌
 7 * @date 2017年4月4日下午9:55:49
 8 */
 9 public class LuxurySeat implements Seat {
10 
11 　　@Override
12 　　public void comfort() {
13 　　　　System.out.println("高端座位舒适度高");
14 　　}
15 
16 }

3.8、抽象工厂模式的产品实现类，低端轮胎:LowTyre.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 /**
 3 * 
 4 * @title LowTyre
 5 * @describe 抽象工厂模式的产品实现类，低端轮胎
 6 * @author 张富昌
 7 * @date 2017年4月4日下午9:55:40
 8 */
 9 public class LowTyre implements Tyre {
10 
11 　　@Override
12 　　public void wear() {
13 　　　　System.out.println("低端轮胎易磨损");
14 　　}
15 
16 }

3.9、抽象工厂模式的产品实现类，高端轮胎：LuxuryTyre.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 /**
 3 * 
 4 * @title LuxuryTyre
 5 * @describe 抽象工厂模式的产品实现类，高端轮胎
 6 * @author 张富昌
 7 * @date 2017年4月4日下午9:55:55
 8 */
 9 public class LuxuryTyre implements Tyre {
10 
11 　　@Override
12 　　public void wear() {
13 　　　　System.out.println("高端轮胎不易磨损");
14 　　}
15 
16 }

3.10、抽象工厂的产品族工厂接口：CarFactory.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title CarFactory
 6 * @describe 抽象工厂的产品族工厂接口
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:54:28
 9 */
10 public interface CarFactory {
11 　　Engine getEngine();
12 
13 　　Seat getSeat();
14 
15 　　Tyre getTyre();
16 }

3.11、抽象工厂的产品族工厂接口的实现类，低端工厂:LowCarFactory.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title LowCarFactory
 6 * @describe 抽象工厂的产品族工厂接口的实现类，低端工厂
 7 * @author 张富昌
 8 * @date 2017年4月4日下午10:07:40
 9 */
10 public class LowCarFactory implements CarFactory {
11 
12 　　@Override
13 　　public Engine getEngine() {
14 　　　　return new LowEngine();
15 　　}
16 
17 　　@Override
18 　　public Seat getSeat() {
19 　　　　return new LowSeat();
20 　　}
21 
22 　　@Override
23 　　public Tyre getTyre() {
24 　　　　return new LowTyre();
25 　　}
26 
27 }

3.12、抽象工厂的产品族工厂接口的实现类，高端工厂:LuxuryCarFactory.java

 1 package cn.com.zfc.gof01.factory.abstractfactory;
 2 
 3 /**
 4 * 
 5 * @title LuxuryCarFactory
 6 * @describe 抽象工厂的产品族工厂接口的实现类，高端工厂
 7 * @author 张富昌
 8 * @date 2017年4月4日下午9:59:38
 9 */
10 public class LuxuryCarFactory implements CarFactory {
11 
12 　　@Override
13 　　public Engine getEngine() {
14 　　　　return new LuxuryEngine();
15 　　}
16 
17 　　@Override
18 　　public Seat getSeat() {
19 　　　　return new LuxurySeat();
20 　　}
21 
22 　　@Override
23 　　public Tyre getTyre() {
24 　　　　return new LuxuryTyre();
25 　　}
26 
27 }

3.13、测试抽象工厂模式:TestAbstractFactory.java

 1 package cn.com.zfc.gof01.factory.abstractfactory.test;
 2 
 3 import cn.com.zfc.gof01.factory.abstractfactory.CarFactory;
 4 import cn.com.zfc.gof01.factory.abstractfactory.Engine;
 5 import cn.com.zfc.gof01.factory.abstractfactory.LuxuryCarFactory;
 6 
 7 /**
 8 * 
 9 * @title TestAbstractFactory
10 * @describe 测试抽象工厂模式
11 * @author 张富昌
12 * @date 2017年4月4日下午10:18:39
13 */
14 public class TestAbstractFactory {
15 　　public static void main(String[] args) {
16 　　　　CarFactory carFactory = new LuxuryCarFactory();
17 　　　　Engine engine = carFactory.getEngine();
18 　　　　engine.efficiency();
19 　　}
20 }