一、前期回顾
上一篇《Java设计模式之单例模式》详细介绍了单例模式，介绍了单例模式的使用场景，优缺点，同时也写了两种常见的单例模式写法，懒汉式单例模式和饿汉氏单例模式，当然，单例模式的写法还有很多，比如，枚举单例模式，静态内部类单例模式等。有兴趣的可以自行查找资料。本篇开始介绍单例模式的第二篇，工厂方法模式，以及工厂模式的升级版，抽象工厂模式。
二、工厂方法模式的定义与实践
定义：Define an interface for creating an object,but let subclasses decide which class to instantiation.Factory Mehod lets a class defer instantiation to subclasses.翻译过来就是，定义一个用于创建对象的接口，让其子类决定实例化哪个类。工厂方法让一个类的实例化延迟到其子类。
上面的定义说明好像很绕口，如果不理解没关系，我们用个例子来说明这个定义：
//定义产品接口
public interface Iproduct {
public void doSomething();
}
//产品实现类
public class ProductA implements Iproduct {
@Override
public void doSomething() {
System.out.println("我是产品A，我可以搞事情");
}
}
//定义工厂类接口
public interface IFactory {
//创建产品工厂方法
< T extends Iproduct> T creatProduct(Class<T> clz);
}
//工厂方法实现类
public class ProductFactory implements IFactory {
@Override
public <T extends Iproduct> T creatProduct(Class<T> clz) {
Iproduct product=null;
try {
product= clz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return (T) product;
}
}
//场景类
public class Client {
public static void main(String[] args) {
IFactory factory=new ProductFactory();
Iproduct product= factory.creatProduct(ProductA.class);
product.doSomething();
}
}
上述例子，实现了一个简单的工厂方法模式，定义了一个工厂接口类，然后具体的工厂方法实现了创建对象的逻辑。看到这里，有人肯定会问，这里要new一个工厂类的实例，和我new一个具体的对象有什么区别呢？反正都要自己new，干嘛要搞一个工厂类这么绕呢？对，没错。这里是要new一个工厂类，但是上面的例子创建产品的对象是比较简单，所以感觉不出来，如果ProductA的实例创建是一个非常复杂的过程，那么这个时候我通过工厂方法模式创建对象的实例就很方便了。
肯定还有人问，我觉得上面这个方式还有点啰嗦，有没有更简便的方式实现工厂模式呢？答案是，有。我们接下来看看简单工厂模式。简单工厂方法模式就是上述工厂方法模式的简单版本。我们只要把上述工厂类的接口去掉，然后把工厂实现类改为静态类就可以实现简单工厂方法模式了。代码是这样的：
//这里只去掉了接口，改为静态方法
public class ProductFactory {
public static <T extends Iproduct> T creatProduct(Class<T> clz) {
Iproduct product=null;
try {
product= clz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return (T) product;
}
}
public class Client {
public static void main(String[] args) {
Iproduct product= ProductFactory.creatProduct(ProductA.class);
product.doSomething();
}
}
这里就不用自己去new 工厂类啦，代码也简洁了很多。但是去掉了接口也就意味着后面的扩展是不友好的，所以违反了开闭原则。
三、抽象工厂模式的定义与实践
定义：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.翻译： 提供一个创建相关或者相互依赖的对象的接口，并且无需指定他们的具体实现类。
这里理解可能有点困难，为了便于理解，我们先引入两个概念。
产品等级结构： 产品等级结构即产品的继承结构，如一个抽象类是汽车，其子类就是各个品牌的汽车，比如奔驰，宝马汽车。汽车和奔驰就构成了一个产品等级结构，抽象汽车是父类，而具体品牌的汽车是其子类。
产品族 ： 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如奔驰工厂生产的奔驰跑车，宝马公司生产的跑车，奔驰跑车位于奔驰产品等级结构中，宝马跑车位于宝马产品等级结构中。
所以，汽车和品牌是一个产品等级结构，而每个品牌下面有多个产品线，也就是说奔驰牌下面的汽车有多个产品族，比如跑车族，SUV族。奔驰跑车和宝马跑车是一个产品族，奔驰SUV和宝马SUV是一个产品族。所以上面定义中“相关或者相互依赖的对象”就是场景中包含，同一个等级结构中有不同的产品族。 ，我们来用一个实际场景来说明下。
假设，我需要一个汽车工厂，汽车可以生产跑车和SUV车型，那么这个时候用之前的工厂方法模式就不满足了，方法工厂模式只能满足生产一个产品，现在需要生产两个产品。所以我们在方法工厂模式的基础上改造下来满足这个场景。
//汽车接口
public interface ICar {
void dirver();
}
//抽象汽车类
public abstract class AbstractProduct implements ICar{
@Override
public void dirver() {
System.out.println("我是汽车，我可以开动");
}
/***
* 展示不同车的亮点*/
public abstract void showSpecial();
}
//宝马SUV实现类
public class BmwSuv extends AbstractProduct {
@Override
public void showSpecial() {
System.out.println("我是宝马牌SUV，我的特点就是多功能用途");
}
}
//宝马跑车实现类
public class BmwProductRoadster extends AbstractProduct {
@Override
public void showSpecial() {
System.out.println("我是宝马跑车，我的特点就是跑的快");
}
}
//奔驰SUV
public class BenzSuv extends AbstractProduct {
@Override
public void showSpecial() {
System.out.println("我是奔驰牌SUV，我的特点就是多功能用途");
}
}
//奔驰跑车
public class BenzProductRoadster extends AbstractProduct {
@Override
public void showSpecial() {
System.out.println("我是奔驰跑车，我的特点就是跑的快");
}
}
//抽象工厂类
public abstract class AbstractFactory {
//创建跑车
public abstract < T extends ICar> T createRoadster();
//创建SUV
public abstract < T extends ICar> T createSuv();
}
//奔驰汽车工厂类
public class BenzFactory extends AbstractFactory {
@Override
public <T extends ICar> T createRoadster() {
return (T) new BenzProductRoadster();
}
@Override
public <T extends ICar> T createSuv() {
return (T) new BenzSuv();
}
}
//宝马汽车工厂类
public class BmwFactory extends AbstractFactory {
@Override
public <T extends ICar> T createRoadster() {
return (T) new BmwProductRoadster();
}
@Override
public <T extends ICar> T createSuv() {
return (T) new BmwSuv();
}
}
//场景类
public class Client {
public static void main(String[] args) {
AbstractFactory bmwFactory=new BmwFactory();
AbstractFactory benzFactory=new BenzFactory();
AbstractProduct bmwRoadster= bmwFactory.createRoadster();
AbstractProduct bmwSuv=bmwFactory.createSuv();
AbstractProduct benzRoadster=benzFactory.createRoadster();
AbstractProduct benzSuv=benzFactory.createSuv();
bmwRoadster.showSpecial();
bmwSuv.showSpecial();
benzRoadster.showSpecial();
benzSuv.showSpecial();
}
}
细心的读者应该发现，我们的改造相对于工厂方法模式而言，只是抽象工厂模式新增了多一个创建方法。这也是抽象工厂模式和工厂方法模式最明显的区别，抽象工厂模式可以满足多类型，多业务的场景，比如汽车工厂可以生产多种类型汽车，就适用于抽象工厂模式。而普通工厂方法模式就是针对生产某一种对象而言比较适用。总结来说就是，抽象工厂模式适用于多产品族的情况，普通工厂方法模式适用于单产品族情况。
四、总结
上面介绍了工厂方法模式与抽象工厂模式的定义与实践，同时也衍生了一个简单工厂模式。我们先来总结下工厂模式的优点与缺点。
优点：
1.良好的封装性，代码结构清晰，不用关注具体对象的创建过程，符合迪米特法则。
2.良好的扩展性，我们扩展了产品，只要新建对应的工厂类，实现自己的实现逻辑即可。
缺点：
1.对于抽象工厂模式，产品族的扩展比较困难，需要修改顶部抽象工厂类，这会导致所有实现类都要修改，不符合开闭原则。
2.对于简单工厂模式，由于没有接口和抽象父类的约束，从而也会导致扩展只能修改代码，不符合开闭原则。
最后我们列一个表格来总结下工厂方法模式，简单工厂模式，抽象工厂模式的区别。
| 简单工厂模式 | 工厂方法模式 | 抽象工厂模式 | |
|---|---|---|---|
| 有无接口或抽象类 | 无 | 有 | 有 |
| 适用场景 | 一般不涉及扩展，单产品族 | 涉及单产品族，便于扩展 | 多产品族场景，可以扩展等级结构，不便于扩展产品族 |
| 实现复杂度 | 最简单 | 简单 | 一般 |
五、参考
《设计模式之禅》
