设计模式 笔记 工厂方法 Factory Methon

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

//factory method 工厂方法-------对象创建型模式

/*

    1:意图：

        定义一个用于创建对象的接口，让子类决定实例化哪一个类。

        Factory Method使一个类的实例化延迟到其子类。

    2:别名： 虚构造器(virtual constructor)

    3:动机：

    4:适用性：

        1>当一个类不知道它所必须创建的对象的类的时候。

        2>当一个类希望由它的子类来指定它所创建的对象的时候。

        3>当类将创建对象的职责委托给多个帮助子类的某一个，并且你希望将哪一个帮助子类是代理者

          这一信息局部化的时候。

    5:结构：

            Product            Creator:

               |               FactorMethod()

               |               AnOperation(){product = FactoryMethod();...}

               |                    |

        ConcreteProduct<- - - -ConcreteCreator:

                                FactoryMethod()

                                {return new ConcereteProduct;}

    6:参与者：

        1>Product：定义工厂方法所创建的对象的接口。

        2>ConcreteProduct：实现Product接口。

        3>Creator：

            1)声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个

              工厂方法的缺省实现，它可以返回一个缺省的ConcreteProduct对象。

            2)可以调用工厂方法以返回一个ConcreteProduct实例。

        4>ConcreteCreator：重定义工厂方法以返回一个ConcreteProduct实例。

    7:协作：Creator依赖于它的子类来定义工厂方法，所以它返回一个适当的ConcreteProduct实例。

    8:效果：

        1>工厂方法只提供了一个处理Product的接口，所以

          可以和用户定义的任何ConcreteProduct类一起使用。

        2>潜在缺点：客户为了创建一个特定的ConcreteProduct对象就不得不创建Creator子类。

        3>另外两种效果：

            1)为子类提供挂钩(hook)。也就是自己先实现一个默认版本的对象，子类可以根据需求

              自行决定是否覆盖父类的版本，自己创建一个特定的对象。

            2)连接平行的类层次。(感觉和hook没区别啊<未知标记>)

    9:实现：

        1>主要有两种不同的情况：

            1)Creator类事一个抽象类并且不提供它所声明的工厂方法的实现：

                需要子类定义实现，因为没有合理的缺省实现，所以避免了不得

                不实例化不可预见类的问题。

            2)Creator是一个具体的类并且为工厂方法提供一个缺省的实现：

                子类可以在必要时改变父类所实例化的对象的类，所以很灵活。

        2>参数化工厂方法：提供一个参数来决定实例化什么特定的类：               */

class Creator

{

public:

   virtual Product* Create(ProductId);

};

Product* Creator::Create(ProductId id)

{

   if(id == MINE) returnnew MyProduct;

   if(id == YOURS) returnnew YourProduct;

   return 0;

}

//        子类可以这么重定义：

Product* MyCreator::Create(ProductId id)

{

   if(id == YOURS) returnnew MyProduct;

   if(id == MINE) returnnew YourProduct;

   if(id == THEIRS) returnnew TheirProduct;

   return Create::Create(id);

}

//        记得最后要调用父类的Create，因为，子类可能有些情况没有处理到，必须交给父类来处理。

//      3>使用模版避免创建子类：

template<class  TheProduct>

class StandardCreator:public Creator

{

public:

   virtual Product* Create()

    {

       return new TheProduct;

    }

};

/*

          这样客户就可以自己提供产品类放入模版中。而不需要我们创建Creator的子类。

        4>命名约定：使用命名约定是一个好习惯，它可以清楚地说明你正在使用的工厂方法。

    10:代码示例：                                                            */

//Creator：

class MazeGame

{

public:

    Maze* CreateMaze();

    

   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 Room Wall Door 都是Product

//ConcreteCreator：

class BombedMazeGame :public MazeGame

{

public:

    BombedMazeGame();

    

   virtual Wall* MakeWall() const

    {return new BombedWall;}

   virtual Room* MakeRoom(int n)const

    {return new RoomWithABomb(n);}

};

//如果客户想要一个带Bombed的迷宫，只需要创建一个BombedMazeGame调用CreateMaze即可。