下面是李建忠老师WebCast中课件内容 还有小山老师Blog中的相应内容:
new的问题
常规的对象创建方法:
// 创建一个Road 对象
Road road=new Road();
new的问题:
– 实现依赖,不能应对“具体实例化类型”的变化。
解决思路:
– 封装变化点—— 哪里变化,封装哪里
– 潜台词:如果没有变化,当然不需要额外的封装!
工厂模式的缘起
• 变化点在“对象创建”,因此就封装“对象创建”
• 面向接口编程——依赖接口,而非依赖实现
• 最简单的解决方法:
class RoadFactory {
public static Road CreateRoad()
{
return new Road();
}
}
// 创建一个Road 对象
Road road=
roadFactory.CreateRoad();
创建一系列相互依赖的对象
假设一个游戏开发场景:
我们需要构造“道路”、
“房屋”、“地道”、“丛
林”……等等对象
Road road=
roadFactory.CreateRoad(
);
…
Building building=
roadFactory.CreateBuildi
ng();
…
class RoadFactory {
public static Road CreateRoad()
{
return new Road();
}
public static Building
CreateBuilding ()
{
return new Building();
}
public static Tunnel
CreateTunnel ()
{
return new Tunnel();
}
public static Jungle
CreateJungle()
{
return new Jungle();
}
简单工厂的问题
简单工厂的问题:
– 不能应对“不同系列对象”的变化。比如有不同风格的游
戏场景——对应不同风格的道路、房屋、地道……
如何解决:
– 使用面向对象的技术来“封装”变化点
动机(Motivation)
在软件系统中,经常面临着“一系列相互依赖的对象”的创建
工作;同时,由于需求的变化,往往存在更多系列对象的
创建工作。
如何应对这种变化?如何绕过常规的对象创建方法(new),
提供一种“封装机制”来避免客户程序和这种“多系列具体对
象创建工作”的紧耦合?
意图(Intent)
提供一个接口,让该接口负责创建一系列“相关或者
相互依赖的对象”,无需指定它们具体的类。
——《设计模式》GoF
结构(Structure)
Abstract Factory模式的几个要点
• 如果没有应对“多系列对象构建”的需求变化,则没有必要
使用Abstract Factory模式,这时候使用简单的静态工厂
完全可以。
• “系列对象”指的是这些对象之间有相互依赖、或作用的关
系,例如游戏开发场景中的“道路”与“房屋”的依赖,“道路”
与“地道”的依赖。
• Abstract Factory模式主要在于应对“新系列”的需求变动。
其缺点在于难以应对“新对象”的需求变动。
• Abstract Factory模式经常和Factory Method模式共同组合
来应对“对象创建”的需求变化。
程序举例:
在什么情形下使用抽象工厂模式:
在以下情况下应当考虑使用抽象工厂模式:
- 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有形态的工厂模式都是重要的。
- 这个系统有多于一个的产品族,而系统只消费其中某一产品族。
- 同属于同一个产品族的产品是在一起使用的,这一约束必须在系统的设计中体现出来。
- 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于实现。
Abstract Factory模式在实际系统中的实现
Herbivore:草食动物
Carnivore:食肉动物
Bison:['baisn],美洲或欧洲的野牛
下面实际代码演示了一个电脑游戏中创建不同动物的抽象工厂。尽管在不同大陆下动物物种是不一样的,但动物间的关系仍然保留了下来。
// Abstract Factory pattern -- Real World example
using System;
// "AbstractFactory"
abstract class ContinentFactory
{
// Methods
abstract public Herbivore CreateHerbivore();
abstract public Carnivore CreateCarnivore();
}
// "ConcreteFactory1"
class AfricaFactory : ContinentFactory
{
// Methods
override public Herbivore CreateHerbivore()
{ return new Wildebeest(); }
override public Carnivore CreateCarnivore()
{ return new Lion(); }
}
// "ConcreteFactory2"
class AmericaFactory : ContinentFactory
{
// Methods
override public Herbivore CreateHerbivore()
{ return new Bison(); }
override public Carnivore CreateCarnivore()
{ return new Wolf(); }
}
// "AbstractProductA"
abstract class Herbivore
{
}
// "AbstractProductB"
abstract class Carnivore
{
// Methods
abstract public void Eat( Herbivore h );
}
// "ProductA1"
class Wildebeest : Herbivore
{
}
// "ProductB1"
class Lion : Carnivore
{
// Methods
override public void Eat( Herbivore h )
{
// eat wildebeest
Console.WriteLine( this + " eats " + h );
}
}
// "ProductA2"
class Bison : Herbivore
{
}
// "ProductB2"
class Wolf : Carnivore
{
// Methods
override public void Eat( Herbivore h )
{
// Eat bison
Console.WriteLine( this + " eats " + h );
}
}
// "Client"
class AnimalWorld
{
// Fields
private Herbivore herbivore;
private Carnivore carnivore;
// Constructors
public AnimalWorld( ContinentFactory factory )
{
carnivore = factory.CreateCarnivore();
herbivore = factory.CreateHerbivore();
}
// Methods
public void RunFoodChain()
{ carnivore.Eat(herbivore); }
}
/**//// <summary>
/// GameApp test class
/// </summary>
class GameApp
{
public static void Main( string[] args )
{
// Create and run the Africa animal world
ContinentFactory africa = new AfricaFactory();
AnimalWorld world = new AnimalWorld( africa );
world.RunFoodChain();
// Create and run the America animal world
ContinentFactory america = new AmericaFactory();
world = new AnimalWorld( america );
world.RunFoodChain();
}
}
开放-封闭"原则
"开放-封闭"原则要求系统对扩展开放,对修改封闭。通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统,其功能增强包括两方面:
增加产品族:Abstract Factory很好的支持了"开放-封闭"原则。
增加新产品的等级结构:需要修改所有的工厂角色,没有很好支持"开放-封闭"原则。
综合起来,抽象工厂模式以一种倾斜的方式支持增加新的产品,它为新产品族的增加提供方便,而不能为新的产品等级结构的增加提供这样的方便。
该程序演示了抽象工厂的结构,本身不具有任何实际价值。
// Abstract Factory pattern -- Structural example
using System;
// "AbstractFactory"
abstract class AbstractFactory
{
// Methods
abstract public AbstractProductA CreateProductA();
abstract public AbstractProductB CreateProductB();
}
// "ConcreteFactory1"
class ConcreteFactory1 : AbstractFactory
{
// Methods
override public AbstractProductA CreateProductA()
{
return new ProductA1();
}
override public AbstractProductB CreateProductB()
{
return new ProductB1();
}
}
// "ConcreteFactory2"
class ConcreteFactory2 : AbstractFactory
{
// Methods
override public AbstractProductA CreateProductA()
{
return new ProductA2();
}
override public AbstractProductB CreateProductB()
{
return new ProductB2();
}
}
// "AbstractProductA"
abstract class AbstractProductA
{
}
// "AbstractProductB"
abstract class AbstractProductB
{
// Methods
abstract public void Interact( AbstractProductA a );
}
// "ProductA1"
class ProductA1 : AbstractProductA
{
}
// "ProductB1"
class ProductB1 : AbstractProductB
{
// Methods
override public void Interact( AbstractProductA a )
{
Console.WriteLine( this + " interacts with " + a );
}
}
// "ProductA2"
class ProductA2 : AbstractProductA
{
}
// "ProductB2"
class ProductB2 : AbstractProductB
{
// Methods
override public void Interact( AbstractProductA a )
{
Console.WriteLine( this + " interacts with " + a );
}
}
// "Client" - the interaction environment of the products
class Environment
{
// Fields
private AbstractProductA AbstractProductA;
private AbstractProductB AbstractProductB;
// Constructors
public Environment( AbstractFactory factory )
{
AbstractProductB = factory.CreateProductB();
AbstractProductA = factory.CreateProductA();
}
// Methods
public void Run()
{
AbstractProductB.Interact( AbstractProductA );
}
}
/**//// <summary>
/// ClientApp test environment
/// </summary>
class ClientApp
{
public static void Main(string[] args)
{
AbstractFactory factory1 = new ConcreteFactory1();
Environment e1 = new Environment( factory1 );
e1.Run();
AbstractFactory factory2 = new ConcreteFactory2();
Environment e2 = new Environment( factory2 );
e2.Run();
}
}