初学Java设计模式随记 -- 工厂方法(Factory Method)模式

工厂方法（Factory Method）模式，又叫做虚拟构造子模式或者多态性工厂模式。

 

1.用意：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

( Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.)

 

2.参与者：

• 抽象产品（Product）：定义工厂方法所创建的对象的接口。
• 具体产品（Concrete Product）： 实现抽象产品的接口。
• 抽象工厂（Creator）： 声明工厂方法，该方法返回一个抽象产品类型的对象。抽象工厂也可以定义一个工厂方法的缺省实现，它返回一个缺省的具体产品对象。可以调用工厂方法以创建一个抽象产品对象。
• 具体工厂（Concrete Creator）：重定义工厂方法以返回一个具体产品实例。

 

3.结构：

  

用现实世界的例子来映射工厂方法模式的定义，如下：

一汽大众（抽象工厂）生产了很多型号的汽车（抽象产品），其中一款奥迪A6（具体产品）由奥迪A6的生产车间（具体工厂）生产。

 

 

如果用工厂方法模式，来实现前一篇随记 初学Java设计模式随记 -- 简单工厂模式（Simple Factory Pattern）中例子6的需求：

一汽大众(工厂类)生产了两款汽车(抽象产品)，一款叫做奥迪A6(具体产品)，另一款叫做奥迪A8(具体产品)。

 

那么，上面的需求描述需要稍微做以下改动：

一汽大众（抽象工厂）生产了两款汽车（抽象产品），一款叫做奥迪A6（具体产品），由奥迪A6工厂（具体工厂）生产；另一款叫做奥迪A8（具体产品），由奥迪A8工厂（具体工厂）生产。

 

Java代码实现，例子7如下：

 

汽车（抽象产品类角色）：

/*
 * 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
 */
public abstract class Car {
	
	public String name;
	
}

  

奥迪A6（具体产品角色）：

/*
 * 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
 */
public class AudiA6Car extends Car {
	
	public AudiA6Car(){
		this.name = "奥迪A6";
		
	}
	
	public String toString(){
		return "一辆"+ this.name;
	}

}

  

奥迪A8（具体产品角色）：

/*
 * 奥迪A8，是一汽大众生产的一款汽车 （具体产品类）
 */
public class AudiA8Car extends Car {
	
	public AudiA8Car(){
		this.name = "奥迪A8";
		
	}
	
	public String toString(){
		return "一辆"+ this.name;
	}

}

  

一汽大众（抽象工厂角色）： 

一汽大众由工厂角色变为抽象工厂角色

/*
 * 抽象工厂角色，使用接口来定义
 */
public interface CarFactory {
	/*
	 * 生产汽车的工厂方法
	 */
	public Car manufactureCar();
}

  

 奥迪A6的生产工厂（具体工厂角色）：

新建了一个具体工厂角色

/*
 * 具体工厂(Concrete Factory)角色
 * 
 * 生产奥迪A6的工厂
 */
public class AudiA6CarsFactory implements CarFactory {
	
	/*
	 * 生产汽车的工厂方法
	 */
	public Car manufactureCar() {
		
//		奥迪A6
		return new AudiA6Car();
	}

}

   

奥迪A8的生产工厂（具体工厂角色）：

新建了一个具体工厂角色

/*
 * 具体工厂(Concrete Factory)角色
 * 
 * 生产奥迪A8的工厂
 */
public class AudiA8CarsFactory implements CarFactory {

	/*
	 * 生产汽车的工厂方法
	 */
	public Car manufactureCar() {
		
//		奥迪A8
		return new AudiA8Car();
	}

}

 

 

 代码的类结构如下：

 

 

客户端的调用：

 

顾客A（客户端）想买一辆奥迪A6，而顾客B（客户端）想买一辆奥迪A8:

在客户端的调用方式也发生了改变，需要先分别创建一个具体工厂对象。

public class Customers {
	
	public static void main(String[] args){
		
//		实例化生产奥迪A6的工厂
		CarFactory audiA6CarFactory = new AudiA6CarsFactory();
//		实例化生产奥迪A８的工厂
		CarFactory audiA8CarFactory = new AudiA8CarsFactory();
		
		System.out.println("===========顾客A买奥迪A6===========");
		
//		顾客A想买一辆奥迪A6,那么工厂需要生产奥迪A6
		Car myCarA6 = audiA6CarFactory.manufactureCar();
		System.out.println("奥迪A6被造好，并且出厂了。");
		
//		顾客A得到了他想要的汽车
		System.out.println("我终于买了"+myCarA6+"。真是太好了！");


		System.out.println("===========顾客B买奥迪A8===========");
	
//		顾客B想买一辆奥迪A8,那么工厂需要生产奥迪A8
		Car myCarA8 = audiA8CarFactory.manufactureCar();
		System.out.println("奥迪A8被造好，并且出厂了。");
		
//		顾客B得到了他想要的汽车
		System.out.println("我终于买了"+myCarA8+"。真是太好了！");
	}

}

 

 

 

运行结果：

===========顾客A买奥迪A6=========== 
奥迪A6被造好，并且出厂了。
我终于买了一辆奥迪A6。真是太好了！ 
===========顾客B买奥迪A8=========== 
奥迪A8被造好，并且出厂了。
我终于买了一辆奥迪A8。真是太好了！

 

对比例子6的简单工厂模式，可以看出原来的工厂类CarFactory被改为了抽象类（接口），新加了两个具体工厂类（实现了工厂接口）来分别创建两个不同的产品。

 

这样做有什么好处呢？

1.满足“开—闭”原则：

1）试想，一汽大众计划生产出第3款型号的汽车奥迪A10。

 

如果使用例子6的简单工厂模式，我们需要修改工厂类CarFactory，来添加新型号汽车的创建逻辑，这种对现有代码的修改，很可能给现有的稳定的系统带来很多不确定性的错误和风险。

 

如果是使用工厂方法模式，我们不需要修改现有的类，只需要添加一个具体产品类，和一个具体工厂类。就很容易实现扩展，同时，不会改变现有系统的稳定性。

 

2）另外，工厂方法模式中不再使用静态的工厂方法（改为普通的方法），这样就便于了工厂类基于继承的等级结构的扩展。

 

例如： 奥迪A6也分不同的型号分类，有红色的，还有黑色的，如果，这两种颜色奥迪A6的生产过程也有很大的不同，就需要不同的工厂来生产。那么，就可以分别创建AudiA6CarsFactory的两个子类AudiA6RedCarsFactory和AudiA6BlackCarsFactory来对汽车的不同等级的产品的生产，进行低风险和方便的扩展。

 

2.满足了“高内聚低耦合”的原则：

综合上面1的1）和2），可以发现随着同级产品的横向扩展和产品等级结构的纵向扩展。都加大了工厂创建产品的复杂程度。

 

如果，采用简单工厂模式，一个工厂类成为了万能类，将各种产品的复杂的创建过程集于一身，这就违反了软件系统中“高内聚低耦合”的原则，在维护和扩展的过程中，就会感觉非常的困难和危险。

 

而如果使用工厂方法模式，将创建不同产品的责任，进行解藕，使得每一个工厂专注于一种产品的创建，满足了“高内聚低耦合”的原则，就使得系统的维护和扩展更加容易和安全。