设计模式 笔记 抽象工厂模式 Abstract Factory

//---------------------------15/04/09----------------------------

//Abstract Factory 抽象工厂----对象创建型模式

/*

1:意图：提供一个创建一系列相关或相互依赖对象的接口，而无需制定他们具体的类。

2:别名：Kit

3:动机

4:适应性：

1>一个系统要独立于它的产品的创建、组合和表示时。

2>一个系统要由多个产品系列中的一个来配置时。

3>当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4>当你提供一个产品类库，而只想显示它们的接口而不是实现时。

5:结构：

AbstractFactory:<---------------------------------------------Client

CreateProductA()                                                |

CreateProductB()                                                |

|                           AbstractProductA<----------------

|                                   |                       |

-----------------                  -----------                  |

|               |                  |         |                  |

ConcreteFactory1:  ConcreteFactor2:- - ->ProductA2   ProductA1<- - -    |

CreateProductA()   CreateProductA() |                               |   |

CreateProductB()   CreateProductB() |                               |   |

|                               |    AbstractProductB<---------------

|                               |           |                   |

|                               |       ---------               |

|                               |       |       |               |

|                               |- ->ProductB2  ProductB1<- - - |

|- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -|

6:参与者：

1>AbstractFactory：声明一个创建抽象产品对象的操作接口。

2>ConcreteFactory：实现创建具体产品对象的操作。

3>AbstractProduct：为一类产品对象声明一个接口。

4>ConcreteProduct：

1)定义一个将被响应的具体工厂创建的产品对象。

2)实现AbstractProduct接口。

5>Client：仅仅使用由AbstractFactory和AbstractProduct类声明的接口。

7:协作：

1>通常在运行时刻创建一个ConcreteFactory类的实例。这一具体的工厂创建具有

特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。

2>AbstractFactory将产品对象的创建延迟到他的ConcreteFactory子类。

8:效果：

1>优点：

1)它分离了具体的类：

AbstractFactory模式帮助控制一个应用创建的对象的类。

因为每一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过

抽象接口就可以操作实例对象，产品的类名耶在具体工厂的实现中被分离。

2)它使得易于交换产品系列：

当客户想要换一套产品系列使用时，只需要改变具体工厂即可

就是在初始化的时候改变使用的工厂，剩下的都无需改变，因为客户使用的是抽象工厂接口。

3)有利于产品的一致性：

当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一系列的对象。

AbstractFactory很容易就能实现。

2>缺点：

难以支持新种类的产品：

想要在一个产品系列中增加一种产品会很难，这样需要改变AbstractFactory的接口

其他子类也需要有所改变。

9:实现：

1>讲工厂作为单件：

一个应用中一般每个系列的产品只需要一个ConcreteFactory的实例。因此

工厂通常最好实现为一个Singleton。

2>创建产品：

AbstractFactory仅声明一个创建产品的接口，真正创建产品是由ConcreteProduct实现的

最常用的是每个产品定义一个工厂方法。一个工厂会为每个产品重定义该工厂指定的产品。

第二种方法是使用Prototype模式来实现，当系列有很多时，可以使用这种方法。

3>定义可扩展的工厂：

一种不安全的办法就是：创建产品的时候传入一个参数(标识)，选择要创建的产品种类，然后返回一个

通用类型的指针(这样做不安全，而且需要所有产品种类有公共的基类，还要有同样的接口)。

10:代码实现：                                                                        */

class MazeFactory

{

public:

MazeFactory();

virtual Maze* MakeMaze()
const

{return
new Maze;}

virtual Room* MakeRoom(int n)const

{return
new Room(n);}

virtual Wall* MakeWall()
const

{return
new Wall;}

virtual Door* MakeDoor(Room* r1, Room* r2)
const

{return
new Door(r1,r2);}

};

Maze* MazeGame::CreateMaze (MazeFactory& factory)

{

Maze* aMaze = factory.MakeMaze();

Room* r1 = factory.MakeRoom();

Room* r2 = factory.MakeRoom();

...

return aMaze;

}

//看看Bombed工厂

Wall* BombedMazeFactory::MakeWall()const

{

return
new BombedWall;

}

Room* BombedMazeFactory::MakeRoom(int n)const

{

return
new RoomWithABomb(n);

}

//只要在创建时换一个工厂就可以创建出不同的产品。