抽象工厂模式——提供一个接口，用于创建相关或依赖对家的家族，而不需要明确指定具体类。（摘自《Head First Design Patterns》）
以下是自已用VS画了一个简图：
创建抽象工厂接口：
public interface IPropertyFactory
{
string CreateIce();
string CreateFire();
string CreateWind();
}
实现二个属性工厂：
class Level1Factory : IPropertyFactory
{
#region IPropertyFactory 成员
public string CreateIce()
{
return "1级冰属性";
}
public string CreateFire()
{
return "1级火属性";
}
public string CreateWind()
{
return "1级风属性";
}
#endregion
}
class Level2Factory : IPropertyFactory
{
#region IPropertyFactory 成员
public string CreateIce()
{
return "2级冰属性";
}
public string CreateFire()
{
return "2级火属性";
}
public string CreateWind()
{
return "2级风属性";
}
#endregion
}
创建武器基类，含有一个属性工厂：
public abstract class Weapon
{
protected string Name = string.Empty;
protected string Property = string.Empty;
protected IPropertyFactory PropertyFactory;
protected abstract void Process();
public void Show()
{
Process();
Console.WriteLine(string.Format("这是一把{0},附加了{1}", Name, Property));
}
}
实现二个武器：
class Sword : Weapon
{
public Sword(IPropertyFactory factory)
{
this.PropertyFactory = factory;
}
protected override void Process()
{
this.Name = "剑";
this.Property = string.Format("{0} {1}", this.PropertyFactory.CreateWind(), this.PropertyFactory.CreateIce());
}
}
class Axe : Weapon
{
public Axe(IPropertyFactory factory)
{
this.PropertyFactory = factory;
}
protected override void Process()
{
this.Name = "斧子";
this.Property = string.Format("{0} {1}", this.PropertyFactory.CreateFire(), this.PropertyFactory.CreateIce());
}
}
开始测试抽象工厂：
IPropertyFactory level1Factory = new Level1Factory();
IPropertyFactory level2Factory = new Level2Factory();
Weapon sword1 = new Sword(level1Factory);
Weapon sword2 = new Sword(level2Factory);
sword1.Show();
sword2.Show();
Weapon axe1 = new Axe(level1Factory);
Weapon axe2 = new Axe(level2Factory);
axe1.Show();
axe2.Show();
测试中分别创建了一级和二级属性工厂，在实例化武器时把工厂加入，不同的工厂就产生了不同的效果，输出结果：
这是一把剑,附加了1级风属性 1级冰属性
这是一把剑,附加了2级风属性 2级冰属性
这是一把斧子,附加了1级火属性 1级冰属性
这是一把斧子,附加了2级火属性 2级冰属性
简单的抽象工厂至此介绍完毕，下面结合一下工厂方法模式：
创建一个武器工厂基类，含有一个属性工厂：
public abstract class WeaponFactory
{
protected IPropertyFactory PropertyFactory;
public abstract Weapon CreateWeapon(string typeName);
}
实现一个普通工厂和一个超级工厂，超级工厂又多含有一个属性工厂，以便能生产不同级别的武器：
class NormalFactory : WeaponFactory
{
public NormalFactory()
{
this.PropertyFactory = new Level1Factory();
}
public override Weapon CreateWeapon(string typeName)
{
switch (typeName)
{
case "sword":
return new Sword(this.PropertyFactory);
case "axe":
return new Axe(this.PropertyFactory);
}
return null;
}
}
class SuperFactory : WeaponFactory
{
protected IPropertyFactory PropertyFactory2;
public SuperFactory()
{
this.PropertyFactory = new Level1Factory();
this.PropertyFactory2 = new Level2Factory();
}
public override Weapon CreateWeapon(string typeName)
{
switch (typeName)
{
case "sword":
return new Sword(this.PropertyFactory);
case "supersword":
return new Sword(this.PropertyFactory2);
case "axe":
return new Axe(this.PropertyFactory);
case "superaxe":
return new Axe(this.PropertyFactory2);
}
return null;
}
}
接下来用新的工厂来生产武器：
WeaponFactory normalFactory = new NormalFactory();
WeaponFactory superFactory = new SuperFactory();
//使用普通工厂
Weapon sword = normalFactory.CreateWeapon("sword");
Weapon axe = normalFactory.CreateWeapon("axe");
sword.Show();
axe.Show();
//使用超级工厂
Weapon superSword = superFactory.CreateWeapon("supersword");
Weapon superAxe = superFactory.CreateWeapon("superaxe");
superSword.Show();
superAxe.Show();
//超级工厂能创建普通工厂的产品
Weapon normalSword = superFactory.CreateWeapon("sword");
Weapon normalAxe = superFactory.CreateWeapon("axe");
normalSword.Show();
normalAxe.Show();
普通工厂只能生产一级武器，而超级工厂能生产一级和二级武器，输出结果：
这是一把剑,附加了1级风属性 1级冰属性
这是一把斧子,附加了1级火属性 1级冰属性
这是一把剑,附加了2级风属性 2级冰属性
这是一把斧子,附加了2级火属性 2级冰属性
这是一把剑,附加了1级风属性 1级冰属性
这是一把斧子,附加了1级火属性 1级冰属性
工厂方法模式和抽象工厂结合就产生了这样的效果，有阐述的不对之处，还请大家指出。
发表于 @ 2008年06月23日 18:02:00|评论(loading...)|收藏