《设计模式精解》学习笔记（八）------Abstract Factory（抽象工厂）模式
《设计模式精解》学习笔记（八）------Abstract Factory（抽象工厂）模式
GoF：Abstract Factory模式的意图是“提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类”。
工厂模式有: 抽象工厂(Abstract Factory)、工厂方法(Factory Method)。依照《设计模式精解》的顺序，这里先学习Abstract Factory模式。
工厂模式是传说中用的最广的模式了。我们通常用某个类Class来生成一个对象，例如：A a = new A(); 所谓工厂就是生产某种产品的地方。那么工厂模式就是用来生成一些列产品（对象）的。有时候，几个对象需要按照相同的样式被实例化。比如说，在处理显示器显示精度的时候，有些机器能显示高清晰图像，而有些机器只能显示低分辨率图像。那么在工作上就要求系统去适配最合适的功能。Abstract Factory模式能确保系统总能根据当前的情况获得合适的对象。
假如我们要开发一个系统，要求提供打印驱动和显示驱动，还要求在不同配置的机器上要有合适的驱动，例如：在高配置的机器上要求精度高的驱动，在低配置的机器上要求精度低的驱动。
开始的解决方法这样：提供一个DisplayDriver抽象类（或者接口）然后派生出两个类Lrdd（提供低精度显示驱动）和Hrdd（提供高精度显示驱动）；再提供一个PrintDriver抽象类（或者接口）然后派生出两个类Lrpd（提供低精度打印驱动）Hrpd（提供高精度打印驱动）。最后在ApControl类中分别实例化四个派生类的对象来提供相关的驱动。这样做是很合理的，但是当需求改变了，现在要求提供中等精度的驱动，或者其它要求。我们又从那两个抽象类中分别派生出若干子类。这样又出现了类爆炸的情况，我们要在ApControl类中分别实例化那些类才能提供我们所要的功能。这时我们就应该想一下用Abstract Factory模式了。先看一下Abstract Factory模式的UML图：
( )
Abstract Factory模式UML图
在上图中我们可以看到，用一个工厂（ResFractory）来“生产”我们需要的“产品”（类）。我们不管有多少具体类，在Abstract Factory模式中ApControl类只使用Abstract Factory类（ResFactory类）和Abstract Product类（DisplayDriver类和PrintDriver类）的接口。通常在运行时刻创建一个具体类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。Abstract Factory将产品对象的创建延迟到它的具体子类中。
下面给出上图的简易代码：
先创建产品：
package Factory;
public abstract class DisplayDriver
{
public abstract void dDriver();//抽象方法，使派生类能够自由实现所需的显示功能。
}//end abstract class DisplayDriver
package Factory;
public class Lrdd extends DisplayDriver
{
public Lrdd()
{
System.out.println("低分辨率__显示驱动");
}//end Lrdd()
public void dDriver() //实现基类抽象方法
{
System.out.println("显示出__低分辨率图像");
}//end dDrover()
}//end class Lrdd
package Factory;
public class Hrdd extends DisplayDriver
{
public Hrdd()
{
System.out.println("高分辨率--显示驱动");
}//end Hrdd()
public void dDriver()
{
System.out.println("显示出--高分辨率图像");
}//end dDriver()
}//end class Hrdd
package Factory;
public abstract class PrintDriver
{
public abstract void pDriver();//抽象方法，使派生类能够自由实现所需的打印功能。
}//end abstract class PrintDriver
package Factory;
public class Lrpd extends PrintDriver
{
public Lrpd()
{
System.out.println("低分辨率__打印驱动");
}//end Lrpd()
public void pDriver()
{
System.out.println("打印__低分辨率图像");
}//end pDriver()
}//end class Lrpd
package Factory;
public class Hrpd extends PrintDriver
{
public Hrpd()
{
System.out.println("高分辨率--打印驱动");
}//end Hrpd()
public void pDriver()
{
System.out.println("打印--高分辨率图像");
}//end pDriver()
}//end class Hrpd
再创建工厂：
package Factory;
public abstract class ResFactory
{
//抽象方法，使派生类自由实现显示功能
abstract public DisplayDriver getDispDrvr();
//抽象方法，使派生类自由实现打印功能
abstract public PrintDriver getPrtDrvr();
}//end abstract class ResFactory
package Factory;
public class LowResFact extends ResFactory {
public LowResFact()
{
System.out.println("低分辨率---->驱动");
}//end LowResFact()
public DisplayDriver getDispDrvr()
{
return new Lrdd();
}//end getDispDrvr()
public PrintDriver getPrtDrvr()
{
return new Lrpd();
}//end getPrtDrvr()
}//end class LowResFact
package Factory;
public class HighResFact extends ResFactory
{
public HighResFact()
{
System.out.println("高分辨率---->驱动");
}//end HighResFact()
public DisplayDriver getDispDrvr()
{
return new Hrdd();
}//end getDispDrvr()
public PrintDriver getPrtDrvr()
{
return new Hrpd();
}//end getPrtDrvr()
}//end class HighResFact
利用工厂产生不同的产品：
package Factory;
public class ApControl
{
private DisplayDriver lowDisplayDriver; //需要--低--分辨率--显示--驱动
private PrintDriver highPrintDriver; //需要--高--分辨率--打印--驱动
// 生产出低分辨率驱动（注：没有说明是低显示驱动还是低打印驱动）
private ResFactory lowDriver;
// 生产出高分辨率驱动（注：没有说明是高显示驱动还是高打印驱动）
private ResFactory highDriver;
public ApControl()
{
lowDriver = new LowResFact();//实例化低分辨率驱动对象
highDriver = new HighResFact();//实例化高分辨率驱动对象
}//end ApControl()
public void displayDriver()
{
lowDisplayDriver = lowDriver.getDispDrvr();//得到低分辨率驱动
lowDisplayDriver.dDriver();//低分辨率显示驱动
highPrintDriver = highDriver.getPrtDrvr();//得到低分辨率驱动
highPrintDriver.pDriver();//高分辨率显示驱动
}//end displayDriver()
public static void main(String[] args)
{
System.out.println("Abstract Factory");
ApControl ac = new ApControl();
ac.displayDriver();
}//end main(...)
}//end class ApControl
输出结果如下：
Abstract Factory
低分辨率---->驱动
高分辨率---->驱动
低分辨率__显示驱动
显示出__低分辨率图像
高分辨率--打印驱动
打印--高分辨率图像
Abstract Factory模式适用性：
l 在以下情况可以使用Abstract Factory模式：
l 一个系统要独立于他的产品的创建、组合和表示时；
l 一个系统要由多个产品系列中的一个来配置时；
l 当你要强调一系列相关的产品对象的设计以便进行联合使用时；
l 当你提供一个产品类库，而只想显示他们的接口而不是实现时。
在Abstract Factory模式中ApControl的责任是知道如何与合适的对象协同工作；ResFactory的责任是提供合适的对象。
Abstract Factory模式：关键特征
l 意图：你需要为特定的客户（或情况）提供特定系列的对象。
l 问题：一系列相关的对象需要被实例化。
l 解决方案：协调不同系列对象的创建过程。提供一种方法保持“如何在客户对象外部执行兑现实例化”的规则，客户对象将使用这些实例化出来的对象。
l 参与者与协作者：Abstract Factory为“如何创建需要的每一个系列的对象”定义接口。典型的情况下，每个系列都独立拥有自己的ConcreteFactory，通过它被实例化。
l 效果：这个模式将“使用哪些对象”的规则与“如何使用这些对象”的逻辑相隔离。
l 实现：定义一个抽象类来指定那些对象将被创建。然后为每个系列实现一个具体类。表或文件也可以被用于达到同样的目的。
下面是Abstract Factory模式涉及的3个关键策略：
1. 发现并封装变化点
“使用哪个驱动对象”的选择食变化的。所以，将它封装在ResFactory类中。
2. 优先使用对象组合，而不是类继承
将变化点放在一个独立的对象——ResFactory对象——中并让ApControl对象使用ResFactory对象，而不是拥有两类不同的ApControl对象。
3. 针对接口设计，而不是针对实现设计
ApControl知道怎样想ResFactory请求实例化驱动对象——它不知道（或不关心）ResFactory对象实际如何响应这一请求。
参考文献：
《Thinking in Patterns》 by Bruce Eckel
《设计模式》 by GoF
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=586034