目录
场景描叙：
1、简单工厂模式
1.1、静态工厂模式
1.2、 使用反射机制进行类注册的简单工厂模式
1.3、使用 newInstance 方法进行类注册的简单工厂模式
2、工厂方法模式
2.1、案例场景：假设有一个汽车工厂，目前只生产两种车型，小型跑车和大型家用车。顾客决定买小还是大型。
2.2、这时候，我们需要拓展业务，增加卡车类的生产，那我们可以创建一个卡车工厂（TruckFactory）。
3、抽象工厂模式
结尾：
场景描叙：
比如小汽车（Car）和 卡车 （Truck）都属于车辆（Vehicle），那我们实例化对象时，就需要分别实例化两个对象。
Vehicle vehicle = new Car();
Vehicle vehicle = new Truck();以上的代码就存在两个问题：
1）类应该保持对扩展开放，对修改关闭（开闭原则）；
每增加新的类造成主要代码修改会打破开闭原则。
2）每个类应该只有一个发生变化的原因（单一职责原则）；
而主类除了自身固有功能还要负责实例化 vehicle 对象，这种行为打破了单一职责原则。
所以这种情况下就需要一种更好的设计方案。我们可以增加一个新类来负责实例化 vehicle 对象，称之为简单工厂模式。
1、简单工厂模式
工厂模式用于实现逻辑的封装，并通过公共接口提供对象的实例化服务，在添加新类时只需要做少量修改即可。
通俗点儿就是封装一个抽象工厂类，实现对象的实例化。
简单工厂的实现描叙如 图 1-1 所示：
图 1-1
1.1、静态工厂模式
我们创建一个抽象 Vehicle 类和继承自它的三个具体类：Bike、Car 和 Truck
package com.zhaoyanfei.designpattern.simpleFactory;
public abstract class Vehicle {
}
package com.zhaoyanfei.designpattern.simpleFactory;
public class Bike extends Vehicle {
}
package com.zhaoyanfei.designpattern.simpleFactory;
public class Car extends Vehicle {
}
package com.zhaoyanfei.designpattern.simpleFactory;
public class Truck extends Vehicle {
}这里，我们写一个简单的工厂类用来创建 Vehicle 实例。工厂类（静态工厂类）代码如下：
package com.zhaoyanfei.designpattern.simpleFactory;
public class VehicleFactory {
public enum VehicleType
{
Bike,Car,Truck;
}
public static Vehicle create(VehicleType type) {
if(type.equals(VehicleType.Bike))
return new Bike();
if(type.equals(VehicleType.Car))
return new Car();
if(type.equals(VehicleType.Truck))
return new Truck();
else return null;
}
}通过上面代码示例，我们可以看到工厂类逻辑非常简单，只负责抽象类 （Vehicle） 类的实例化，符合单一职责原则，用户只需要调用 Vehicle 接口，这么做可以减少耦合，符合依赖倒置原则；但是增加一个新的 Vehicle 类时，需要对 VehicleFactory 工厂类进行修改，就打破了开闭原则。
我们可以改进这种简单工厂模式，使得注册的新类在使用时才被实例化，从而保证其对扩展开放，对修改关闭。
具体实现方式有以下两种：
1）使用反射机制注册产品类对象和实例化。
2）注册产品对象并向每个产品添加 newInstanse 方法，该方法返回与自身类型相同的新实例。
1.2、 使用反射机制进行类注册的简单工厂模式
这里，我们在工厂类中需要用 map 对象来保存产品 ID 及其对应的类：
然后增加一个注册新 Vehicle 类的方法
package com.zhaoyanfei.designpattern.simpleFactory;
import java.util.HashMap;
import java.util.Map;
public class VehicleFactory {
public enum VehicleType
{
Bike,Car,Truck;
}
public static Vehicle create(VehicleType type) {
if(type.equals(VehicleType.Bike))
return new Bike();
if(type.equals(VehicleType.Car))
return new Car();
if(type.equals(VehicleType.Truck))
return new Truck();
else return null;
}
//工厂类中需要用 map 对象来保存产品 ID 及其对应的类
private Map<String,Class> registeredProducts = new HashMap<String,Class>();
//然后增加一个注册新 Vehicle 类的方法
public void registerVehicle(String vehicleId,Class vehicelClass) {
registeredProducts.put(vehicleId, vehicelClass);
}
//构造方法如下所示：
public Vehicle createVehicle(String type) throws InstantiationException, IllegalAccessException {
Class productClass = registeredProducts.get(type);
return (Vehicle) productClass.newInstance();
}
}上面代码中，我们可以看到反射实例化对象时，会有异常抛出。所以在某些情况下，反射机制并不适用。另外，反射机制也会降低程序的运行效率，在对性能要求很高的场景下应该避免使用这种机制。
1.3、使用 newInstance 方法进行类注册的简单工厂模式
前面我们用的反射机制来实现新 Vehicle 类的实例化。如果要避免使用反射机制，可以使用注册新 Vehicle 类的类似工厂类，不再将类添加到 map 对象中，而是将要注册的每种对象实例添加其中。每个产品类都能够创建自己的实例。
1）首先在基类 Vehicle 中添加一个抽象方法：
package com.zhaoyanfei.designpattern.simpleFactory;
public abstract class Vehicle {
abstract public Vehicle newInstance();
}2）此时，大家都知道，子类必须实现基类中声明的抽象方法：
Bike、Car 和 Truck 都需要实现 newInstance()方法，每个产品类创建自己的实例。
package com.zhaoyanfei.designpattern.simpleFactory;
public class Bike extends Vehicle {
@Override
public Vehicle newInstance() {
return new Bike();
}
}3）在工厂类中，更改 map 用于保存对象的 ID 及其对应的 Vehicle 对象：
package com.zhaoyanfei.designpattern.simpleFactory;
import java.util.HashMap;
import java.util.Map;
public class VehicleFactory {
public enum VehicleType
{
Bike,Car,Truck;
}
public static Vehicle create(VehicleType type) {
if(type.equals(VehicleType.Bike))
return new Bike();
if(type.equals(VehicleType.Car))
return new Car();
if(type.equals(VehicleType.Truck))
return new Truck();
else return null;
}
/**
* 反射机制
*/
//工厂类中需要用 map 对象来保存产品 ID 及其对应的类
// private Map<String,Class> registeredProducts = new HashMap<String,Class>();
// //然后增加一个注册新 Vehicle 类的方法
// public void registerVehicle(String vehicleId,Class vehicelClass) {
// registeredProducts.put(vehicleId, vehicelClass);
// }
// //构造方法如下所示：
// public Vehicle createVehicle(String type) throws InstantiationException, IllegalAccessException {
// Class productClass = registeredProducts.get(type);
// return (Vehicle) productClass.newInstance();
// }
/**
* 注册产品对象，并向每个产品添加 newInstance 方法，该方法返回与自身类型相同的新实例
*/
private Map<String,Vehicle> registeredProducts = new HashMap<String,Vehicle>();
//然后增加一个注册新 Vehicle 类的方法
public void registerVehicle(String vehicleId,Vehicle vehicle) {
registeredProducts.put(vehicleId, vehicle);
}
//构造方法如下所示：
public Vehicle createVehicle(String type) {
Vehicle productClass = registeredProducts.get(type);
return productClass.newInstance();
}
}2、工厂方法模式
工厂方法模式（FACTORY METHOD）是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品
工厂方法模式是在静态工厂模式上的改进。工厂类被抽象化，用于实例化特定产品类的代码被转移到实现抽象方法的子类中。这样就不需要修改就可以扩展工厂类。实现如 图2-1：
2.1、案例场景：假设有一个汽车工厂，目前只生产两种车型，小型跑车和大型家用车。顾客决定买小还是大型。
1）首先我们需要创建一个 Vehicle 类和两个子类，子类分别为 SportCar 和 SedanCar。
package com.zhaoyanfei.designpattern.factorymethod;
public class Vehicle {
String color;
public void setColor(String color) {
this.color = color;
}
} package com.zhaoyanfei.designpattern.factorymethod;
public class SportCar extends Vehicle {
} package com.zhaoyanfei.designpattern.factorymethod;
public class SedanCar extends Vehicle {
}2）创建抽象工厂类，此类中不包含任何创建新实例的代码：
package com.zhaoyanfei.designpattern.factorymethod;
public abstract class VehicleFactory {
protected abstract Vehicle createVehicle(String item);
public Vehicle orderVehicle(String size,String color) {
Vehicle vehicle = createVehicle(size);
vehicle.setColor(color);
return vehicle;
}
}3）增加汽车实例化代码，我们创建 VehicleFactory 的子类
package com.zhaoyanfei.designpattern.factorymethod;
public class CarFactory extends VehicleFactory {
@Override
protected Vehicle createVehicle(String size) {
if(size.equals("small")) {
return new SportCar();
}else if(size.equals("large")) {
return new SedanCar();
}else {
return null;
}
}
}4）客户端，我们只需要创建工厂类并创建订单：
package com.zhaoyanfei.designpattern.factorymethod;
public class TestMethodFactory {
public static void main(String[] args) {
VehicleFactory carFactory = new CarFactory();
Vehicle orderVehicle = carFactory.orderVehicle("large", "green");
System.out.println("类名："+orderVehicle.getClass().getName()+"颜色："+orderVehicle.color);
}
}运行后可以看到如下输出：
2.2、这时候，我们需要拓展业务，增加卡车类的生产，那我们可以创建一个卡车工厂（TruckFactory）。
package com.zhaoyanfei.designpattern.factorymethod;
public class TruckFactory extends VehicleFactory {
@Override
protected Vehicle createVehicle(String size) {
if(size.equals("small")) {
return new SmallTruck();
}else if(size.equals("large")) {
return new LargeTruck();
}else {
return null;
}
}
}我们就可以这样来创建卡车订单了：
VehicleFactory truckFactory = new TruckFactory();
Vehicle orderVehicle = truckFactory.orderVehicle("large", "blue");3、抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的扩展版本。它不再是创建单一类型的对象，而是创建一系列相关联的对象，如果说工厂方法模式中只包含一个抽象产品类，那么抽象工厂模式则包含多个抽象产品类。所以说工厂方法模式只是抽象工厂模式的一种特例。
抽象工厂设计模式的实现如图 3-1 所示：
图 3-1
抽象工厂模式由以下类组成：
AbstractFactory （抽象工厂类）：抽象类，用于声明创建不同类型产品的方法。它针对不同的抽象产品类都有对应的创建方法。
ConcreteFactory （具体工厂类）：具体类，用于实现抽象工厂基类中声明的方法。针对每个系列的产品都有一个对应的具体工厂类。
AbstractProduct（抽象产品类）：对象所需要的基本接口或类。一簇相关产品类由来自不同层级的相似产品类组成。ProductA1 和 ProductB1 来自第一个类簇，由 ConcreteFactory1 实例化。ProductA2 和 ProductB2 来自第二个类簇，由 ConcreteFactory2 实例化。
结尾：
工厂的模式的核心就是右工厂类来负责合适对象的创建。如果工厂类很复杂，比如同时服务于多种类型的对象或工厂，也可以根据前面内容修改相应的代码。
下一节，分享建造者模式……
