FrankFei,2007年3月9日
一、概述
在软件系统中,经常面临着“某个对象”的创建工作,由于需求的变化,这个对象的具体实现经常面临着剧烈的变化,但是它却拥有比较稳定的接口。如何应对这种变化?提供一种封装机制来隔离出“这个易变对象”的变化,从而保持系统中“其它依赖该对象的对象”不随着需求的改变而改变?这就是要说的Factory Method模式了。
在软件系统中,经常面临着“某个对象”的创建工作,由于需求的变化,这个对象的具体实现经常面临着剧烈的变化,但是它却拥有比较稳定的接口。如何应对这种变化?提供一种封装机制来隔离出“这个易变对象”的变化,从而保持系统中“其它依赖该对象的对象”不随着需求的改变而改变?这就是要说的Factory Method模式了。
二、意图
定义一个用户创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。
三、结构图
四、举例
public abstract class Light
{
public abstract void TurnOn();
public abstract void TurnOff();
}
public class BulbLight : Light
{
public override void TurnOn()
{ Console.WriteLine("Bulb Light is Turned on"); }
public override void TurnOff()
{ Console.WriteLine("Bulb Light is Turned off"); }
}
public class TubeLight : Light
{
public override void TurnOn()
{ Console.WriteLine("Tube Light is Turned on"); }
public override void TurnOff()
{ Console.WriteLine("Tube Light is Turned off"); }
}
public abstract class Creator
{
public abstract Light factory();
}
public class BulbCreator : Creator
{
public override Light factory()
{ return new BulbLight(); }
}
public class TubeCreator : Creator
{
public override Light factory()
{ return new TubeLight(); }
}
//Client
class Program
{
static void Main(string[] args)
{
Creator c1 = new BulbCreator();
Creator c2 = new TubeCreator();
Light l1 = c1.factory();
Light l2 = c2.factory();
l1.TurnOn();
l1.TurnOff();
Console.WriteLine("-----------------");
l2.TurnOn();
l2.TurnOff();
}
}
{
public abstract void TurnOn();
public abstract void TurnOff();
}
public class BulbLight : Light
{
public override void TurnOn()
{ Console.WriteLine("Bulb Light is Turned on"); }
public override void TurnOff()
{ Console.WriteLine("Bulb Light is Turned off"); }
}
public class TubeLight : Light
{
public override void TurnOn()
{ Console.WriteLine("Tube Light is Turned on"); }
public override void TurnOff()
{ Console.WriteLine("Tube Light is Turned off"); }
}
public abstract class Creator
{
public abstract Light factory();
}
public class BulbCreator : Creator
{
public override Light factory()
{ return new BulbLight(); }
}
public class TubeCreator : Creator
{
public override Light factory()
{ return new TubeLight(); }
}
//Client
class Program
{
static void Main(string[] args)
{
Creator c1 = new BulbCreator();
Creator c2 = new TubeCreator();
Light l1 = c1.factory();
Light l2 = c2.factory();
l1.TurnOn();
l1.TurnOff();
Console.WriteLine("-----------------");
l2.TurnOn();
l2.TurnOff();
}
}
五、优点
1、工厂方法使类中的代码不依赖于它必须创建的类,代码只要知道它需要创建的类的接口;
现在我们根据这句话来分析一下上面的例子:
1)工厂方法使类中的代码不依赖于它必须创建的类,对应于Creator c1 = new BulbCreator();也就是这行代码想要创建一个灯泡实例,但它并没有使用new BulbLight();这样,如果因需求迫使BulbLight类发生变化时,虽然客户程式是依赖于BulbLight,但此时并不会因为BulbLight的变化而使客户程式发生变化。
2)代码只要知道它需要创建的类的接口,对应于两个抽象类:Creator和Light
注:在客户程式中使用了具体类BulbCreator和TubeCreator,这个可以通过配置文件和反射来完成,详见:抽象工厂模式
六、缺点
1、新增加一个需要创建的类,就需要增加一个相应的子类;
七、适用性
1、当一个类不知道它所必须创建的对象的类的时候;
2、当一个类希望由它的子类来指定它所创建的对象的时候;
3、当类将创建对象的职责委托给多个帮助子类中的某一个,并且你希望将哪一个帮助子类是代理者这一信息局部化的时候;
2、当一个类希望由它的子类来指定它所创建的对象的时候;
3、当类将创建对象的职责委托给多个帮助子类中的某一个,并且你希望将哪一个帮助子类是代理者这一信息局部化的时候;
八、实现要点
1、Factory Method模式的两种情况:一是Creator类是一个抽象类且它不提供它所声明的工厂方法的实现;二是Creator是一个具体的类且它提供一个工厂方法的缺省实现。
2、工厂方法是可以带参数的。
3、工厂的作用并不仅仅只是创建一个对象,它还可以做对象的初始化,参数的设置等。
2、工厂方法是可以带参数的。
3、工厂的作用并不仅仅只是创建一个对象,它还可以做对象的初始化,参数的设置等。
九、.Net Framework中的应用
1、获得迭代器
.NET中的集合和列表等聚合都提供了对自身进行遍历访问的迭代方法,集合实现IEnumerable接口,而迭代器实现IEnumerator接口。因为迭代器不能脱离聚合独立存在,所以其本身没有公开的构造函数,只能通过聚合创建。不同的聚合采用不同的迭代器,在IEnumerable中定义了产生迭代器的接口,即工厂方法。如图所示。
实现IEnumerable接口的类,如ArrayList等集合类实现了GetEnumerator函数,即实现了工厂方法的具体实现。根据不同的类,获得不同的IEnumerator。例如,ArrayList中的GetEnumerator返回的IEnumerator是ArrayListEnumeratorSimple,Sting中的GetEnumerator 返回的IEnumerator是 CharEnumerator:
using System;
using System.Collections;
namespace Enumerator
{
public class Class1
{
[STAThread]
static void Main(sting[] args)
{
ArrayList a = new ArrayList();
IEnuemrator e = a.GetEnumerator();
System.Console.WriteLine(e.GetType().Name);
String s = "";
IEnumerator se = s.GetEnumerator();
System.Console.WriteLine(se.GetType().Name);
System.Console.ReadLine();
}
}
}
using System.Collections;
namespace Enumerator
{
public class Class1
{
[STAThread]
static void Main(sting[] args)
{
ArrayList a = new ArrayList();
IEnuemrator e = a.GetEnumerator();
System.Console.WriteLine(e.GetType().Name);
String s = "";
IEnumerator se = s.GetEnumerator();
System.Console.WriteLine(se.GetType().Name);
System.Console.ReadLine();
}
}
}
在这里,工厂方法起到了连接类层次的作用。
现在我们再来分析上面.Net Framework中的例子:
1)IEnumerator对应于Light,ArrayListEnumeratorSimple对应于BulbLight,CharEnumerator对应于TubeLight;
2)IEnumerable对应于Creator,ArrayList对应于BulbCreator,String对应于TubeCreator;
3)可以把上面的例子改为下面的例子更容易理解,虽然实际编程时不会这样写:
using System;
using System.Collections;
namespace Enumerator
{
public class Class1
{
[STAThread]
static void Main(sting[] args)
{
IEnumerable a = new ArrayList();
IEnuemrator e = a.GetEnumerator();
System.Console.WriteLine(e.GetType().Name);
IEnumerable s = "";
IEnumerator se = s.GetEnumerator();
System.Console.WriteLine(se.GetType().Name);
System.Console.ReadLine();
}
}
}
using System.Collections;
namespace Enumerator
{
public class Class1
{
[STAThread]
static void Main(sting[] args)
{
IEnumerable a = new ArrayList();
IEnuemrator e = a.GetEnumerator();
System.Console.WriteLine(e.GetType().Name);
IEnumerable s = "";
IEnumerator se = s.GetEnumerator();
System.Console.WriteLine(se.GetType().Name);
System.Console.ReadLine();
}
}
}
十、总结
工厂方法模式(Factory Method Pattern)它不是用一个专门的类来决定实例化哪一个子类。相反,超类把这种决定延迟到每个子类。这种模式实际上没有决策点,既没有直接选择一个子类实例化的决策。按这种模式编写的程序定义了一个抽象类,它去创建对象,但让子类决定创建一种对象。Factory Method要解决的就是对象的创建时机问题,它提供了一种扩展的策略,很好地符合了开放封闭原则。
参考文献
《敏捷软件开发-原则、模式与实践》 Robert C. Martin
《.Net与设计模式》 甄镭
《Java与模式》 阎宏
“网络资源”
参考文献
《敏捷软件开发-原则、模式与实践》 Robert C. Martin
《.Net与设计模式》 甄镭
《Java与模式》 阎宏
“网络资源”