初学Java设计模式随记 -- 抽象工厂(Abstract Factory)模式
?抽象工厂(Abstract Factory)模式的定义如下：
??
1. 用意： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
(Provide an interface for creating families of related or dependent objects without specifying their concrete classes.)
?
2. 参与者:（5种角色）
? 抽象工厂（AbstractFactory）： 声明一个创建抽象产品对象的操作接口。
? 具体工厂（ConcreteFactory）： 实现创建具体产品对象的操作。
? 抽象产品（AbstractProduct）： 为一类产品对象声明一个接口。
? 具体产品（ConcreteProdcut）： 定义一个将被相应的具体工厂创建的产品对象。实现抽象产品（AbstractProduct）接口。
? 客户端（Client）：仅使用由抽象工厂（AbstractFactory）和抽象产品（AbstractProduct）类声明的接口。
?
在刚看到客户端（client）这个角色的时候，有点迷惑，不知道客户端（client）在抽象工厂模式中是什么作用？
它与之前学习“简单工厂模式”和“工厂方法模式”时，写的那例子（1~7）中的客户端（Customer）是否一样?是代表的同一个意思吗？如果一样，为什么工厂方法模式里没有客户端（client）这个参与者呢？
?
在GOF的设计模式中，包含了“客户端（Client）”这个参与者；而在阎宏的《Java与模式》中没有包含“客户端（Client）”这个参与者。
?
后来，似乎明白了，客户端（client）应该会使用抽象工厂来将抽象产品给组装起来，并为使用抽象工厂模式的客户端（Customer）提供了一个调用接口。在下面的例子8中将来理解客户端（client）的作用。
其实在很多资料的例子中，都将客户端（Client）合并到了抽象工厂中，也有合并到客户端（Customer）中的。
?
3. 结构：
图1：在GoF的设计模式中（类似下面的形式）
?
图2：在阎宏的《Java与模式》中（类似下面的形式）
?
?
?
看到抽象工厂模式，总是会拿工厂方法模式与它作比较。
?
这两个模式有四个相同的角色：
抽象工厂（AbstractFactory）--->具体工厂（ConcreteFactory）
抽象产品（AbstractProduct）--->具体产品（ConcreteProdcut）
?
那么，这两个模式有什么不同呢？?
?
看看用意有什么不同:
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.抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
(Provide an interface for creating families of related or dependent objects without specifying their concrete classes.)
?
通过这两个模式的用意，可以看出：
1.工厂方法模式是用来创建一个产品对象的，也就是说，每个抽象工厂是用来创建一种抽象产品对象，继承抽象工厂的每个具体工厂是用来创建一种具体产品对象的。
2.抽象工厂模式是用来创建多个（一套或一系列）产品对象的，也就是说，每个抽象工厂是用来创建多种（一套或一系列）抽象产品对象，继承抽象工厂的每个具体工厂都可以用来创建多种（一套或一系列）具体产品对象的。
?
依然以“生产汽车”为例，那么，
1.工厂方法模式下，每个汽车是一个产品对象（发动机，车门等汽车零部件都被看作是汽车的属性）。
工厂生产汽车的过程，实际上只是组装汽车零部件的过程。
2.抽象工厂模式下，每个汽车由一套汽车零部件产品对象（发动机，车门等都是产品，不再是属性）组成的。
工厂生产汽车的过程，就变成了，先生产各个汽车零部件产品，然后再组装汽车零部件的过程。
?
在阎宏的《JAVA与模式》?中是这么说的：
抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级机构。
?
“产品等级结构”这个词给人感觉很抽象。
1.什么是一个产品等级结构？
奥迪A6,奥迪A8,甚至加上宝马X6,可以看作是一个产品等级的，因为他们都是汽车。
红色的奥迪A6，黑色的奥迪A8，甚至加上宝马，也可以被看作是一个产品等级的，因为它们都是汽车。
图3：
?
?
上面每种汽车的发动机，奥迪A6的发动机，奥迪A8的发动机，（这里假设发动机的型号不同），也同样可以被看作是一个产品等级的，因为它们都是发动机。
图4：
?
2.什么是多个产品等级机构？
奥迪A6的发动机，奥迪A6的车门，奥迪A6的轮胎，这些是多个产品等级结构的，因为它们是不同类的产品。
也就是说发动机，车门，轮胎以及其他的汽车部件各自代表了一类产品，不存在继承和实现的关系，没有什么交集。
?
它们之间是一种平行关系，但是它们之间组合起来，就可以组成一个汽车（一个产品族）。
一个奥迪A6汽车就是一系列的奥迪A6的发动机、奥迪A6的车门、奥迪A6的轮胎等其他汽车零部件产品的组合。
?
图5：
??
?
抽象工厂模式的例子和Java实现：
?
顾客想购买一汽大众的汽车，汽车的发动机和车身，也要求是对应的型号。
A想购买奥迪A6，顾客A想购买奥迪A8。例子8:
?
汽车发动机(抽象产品)：
?
/* * 汽车发动机(抽象产品) */public interface Engine {}?
奥迪A6的发动机（具体产品）：
?
/* * 奥迪A6的发动机（具体产品） */public class AudiA6Engine implements Engine{public String toString(){return "奥迪A6发动机";}}?
奥迪A8的发动机（具体产品）：
?
/* * 奥迪A8的发动机（具体产品） */public class AudiA8Engine implements Engine{public String toString(){return "奥迪A8发动机";}}?
?
汽车车身（抽象产品）：
?
/* * 汽车车身（抽象产品） */public interface CarBody {}?
奥迪A6的车身（具体产品）：?
??
/* * 奥迪A6的车身（具体产品） */public class AudiA6CarBody implements CarBody {public String toString(){return "奥迪A6车身";}}?
奥迪A8的车身（具体产品）：
?
/* * 奥迪A8的车身（具体产品） */public class AudiA8CarBody implements CarBody {public String toString(){return "奥迪A8车身";}}?
?
一汽大众工厂（抽象工厂）：
?
/* * 一汽大众工厂（抽象工厂） */public interface CarFactory {/* * 生产汽车发动机的工厂方法（创建一种产品对象） */public Engine createEngine();/* * 生产汽车车身的工厂方法（创建另一种产品对象） */public CarBody createCarBody();}?
奥迪A6工厂（具体工厂）：
?
/* * 奥迪A6工厂（具体工厂） */public class AudiA6CarFactory implements CarFactory {/* * 生产奥迪A6发动机的工厂方法（创建一种具体产品对象） */public CarBody createCarBody() {return new AudiA6CarBody();}/* * 生产奥迪A6车身的工厂方法（创建另一种具体产品对象） */public Engine createEngine() {return new AudiA6Engine();}}?
奥迪A8工厂（具体工厂）：
?
/* * 奥迪A8工厂（具体工厂） */public class AudiA8CarFactory implements CarFactory {/* * 生产奥迪A6发动机的工厂方法（创建一种具体产品对象） */public CarBody createCarBody() {return new AudiA8CarBody();}/* * 生产奥迪A6车身的工厂方法（创建另一种具体产品对象） */public Engine createEngine() {return new AudiA8Engine();}}?
汽车（客户端）：
汽车实际上就是一个产品族，即一套（一系列）汽车零部件产品（产品族）组合。
这里定义了一个Car类，只使用了抽象工厂（CarFactory）和抽象产品（Engine 、CarBody ），不涉及任何具体工厂（AudiA6CarFactory、AudiA8CarFactory）和具体产品（AudiA6Engine 、AudiA8Engine、AudiA6CarBody?、AudiA8CarBody?）。
?
/* * 汽车（客户端） * 通过生产发动机的工厂和生产车身的工厂，生产汽车发动机和汽车车身， * 最终，汽车由一套产品族（一套汽车零部件）组成。 */public class Car {private CarBody body;private Engine engine;public Car(CarFactory carFactory){this.body = carFactory.createCarBody();this.engine = carFactory.createEngine();}public String toString(){return "[" + this.body+"/" + this.engine + "]";}}?
客户端的调用（用于测试）：
在调用抽象工厂模式时，使用了客户端（Client）角色Car，因为Car类的构造函授的传入参数类型是抽象工厂。
这样，我们根据需要，只要传入一个期望的具体工厂对象（AudiA6CarFactory），就可以得到期望的产品族（adioA6Car）对象。
当想得到另一种产品族（adioA8Car）对象，只要传入另一个具体工厂对象（AudiA8CarFactory）就可以了。?
?
/* * 使用抽象工厂的客户端（用于测试） */public class Customers { public static void main(String[] args){//创建一个奥迪A6生产工厂（具体工厂对象）CarFactory adioA6CarFactory = new AudiA6CarFactory();//顾客A购买了奥迪A6（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））Car adioA6Car = new Car(adioA6CarFactory);System.out.println("顾客A买了一辆汽车" + adioA6Car);//创建一个奥迪A8生产工厂（具体工厂对象）CarFactory adioA8CarFactory = new AudiA8CarFactory();//顾客B购买了奥迪A8（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））Car adioA8Car = new Car(adioA8CarFactory);System.out.println("顾客B买了一辆汽车" + adioA8Car);}}?
运行结果：
顾客A买了一辆汽车[奥迪A6车身/奥迪A6发动机]顾客B买了一辆汽车[奥迪A8车身/奥迪A8发动机]
?
?
?本例子的结构图：
??
?
?
?
?
?
小小总结一下，通过比较工厂方法模式，了解抽象工厂模式的优点：
1. 通过用意比较，
使用抽象工厂模式的目的---为了创建一系列相关或相互依赖（几个或几类）对象；
而使用工厂方法模式的目的--为了创建（一个或一类）对象。
2.通过结构比较，
因为抽象工厂模式是为了创建多个有关联的产品对象，因此增加了一个客户端（Client）角色，用于整合创建出来的产品族。
同时，抽象工厂模式的工厂不是哪一种产品的工厂，它是多种产品的工厂。我想，这可能就是抽象工厂模式的工厂被成为“抽象”工厂的原因吧。也就是说，它的“抽象”是对多种产品的“抽象”。
?
?
在很多资料以及实际应用中，大多通过结合配置文件以及反射来充分体现抽象工厂模式的优势。
在下面的链接是一位博主使用.NET来讲解的抽象工厂模式，我觉得简单易懂，而且在实际应用中很有参考价值。
.NET设计模式（3）：抽象工厂模式（Abstract Factory）
?