一、一個MAZE的構造過程

Maze的UML diagram如圖所示

可以發現MapSite是斜體表示抽象類，有Room, Door, Wall三個子類繼承，這三個就是用繼承封裝了MapSite的多向性。然而一個Maze，就是Room的聚合，所以Maze通過AddRoom方法來新增這些聚合這些Room. 最後通過MazeGame這個類，來構造這個Maze, 也就是幫助Maze這個物件執行它的AddRoom方法，幫Maze傳遞訊息。所以我說， MazeGame就是Maze的建立類。重點看這個MazeGame建立類

class MazeGame {
  public:
    Maze* CreateMaze();//本節將要介紹的建立方法
    
    Maze* CreateSimpleMaze();
    Maze* CreateMaze(MazeFactory&);//後面講的AbstractFactory模式
    Maze* CreateMaze(MazeBuilder&);//後面講的Builder模式
    
    Maze* CreateComplexMaze (MazeBuilder& builder);
    //構建各種不同迷宮的方法入口
};
 

看看CreateMaze(）方法如何實現：

Maze* MazeGame::CreateMaze() {
    Maze* aMaze = new Maze;
    Room* r1 = new Room(1);
    Room* r2 = new Room(2);
    Door *theDoor = new Door(r1, r2);

    aMaze->AddRoom(r1);
    aMaze->AddRoom(r2);

    r1->SetSide(North, new Wall);
    r1->SetSide(East, theDoor);
    r1->SetSide(South, new Wall);
    r1->SetSide(West, new Wall);
    r2->SetSide(North, new Wall);
    r2->SetSide(East, new Wall);
    r2->SetSide(South, new Wall);
    r2->SetSide(West, theDoor);

    return aMaze;
}
 

可以看出，這個Maze被create出來的結構是單一的，就只可能是兩個房間，如何自由定義房間空間個數和四壁的內容而不重寫程式碼，這個問題後面是不能解決的。同時，the room, the wall, the door的性質，在SetSide裡面已經定義死了，如果下面我們需要給這個Maze定義兩種風格，第一種風格是room加上魔法room，door加上用魔法才能開啟的魔法Maze, 第二種風格room裡面可能有炸彈，走到炸彈裡面就死了的炸彈Maze, 用非繼承的方法，那麼我們呢需要重新寫兩個Room這個類，在EnchantedMaze中要擴充套件一個EnchantedRoom類，在BombedMaze中要擴充套件RoomWithABoom類，如下圖所示。

一般的思維，是在CreateMaze的時候，輸入的物件還是那個Maze, 但需要給Maze新增一個風格屬性，同時在CreateMaze()開頭就要新增一行語句判斷建立的是哪種風格的Maze, 然後分別對不同的Maze.style, 需要改Room* r1 = new Room(1) 為 Room* r1 = new EnchantedRoom(1) 和 Room* r1 = new RoomWithABomb(1) ,這樣一下子就增加了很多的程式碼量，因為case變多了。所以第一個想法就是調整CreateMaze的輸入，這樣引出了第一種模式AbstractFactory.

二、AbstractFactory

在我們定義一個基礎類AbstractFactory, 然後再派生出ConcreteFactory， 這每一個ConcreteFactory的類裡面都定義了各自創屬於自己風格的Room和Wall的方法。 帶入到Maze裡面的程式碼如下

class MazeFactory {
public:
    MazeFactory();
    virtual Maze* MakeMaze() const;
    virtual Wall* MakeWall() const;
    virtual Room* MakeRoom(int n) const;
    virtual Door* MakeDoor(Room* r1, Room* r2) const;
}; //這個是基礎的AbstractFactory，以後不同風格的ConcreteFactory都是繼承此。
//AbstractFactory提供建立Maze類物件的方法，並且提供建立Wall，Room，Door的方法，然後讓CreateMaze()來呼叫這個Factory中的方法建立Maze
Maze* MazeFactory::MakeMaze() const 
        { return new Maze; }
Wall* MazeFactory::MakeWall() const
        { return new Wall; }
Room* MazeFactory::MakeRoom(int n) const
        { return new Room(n); }
Door* MazeFactory::MakeDoor(Room* r1, Room* r2) const
        { return new Door(r1, r2); }

下面是實現了BomdedMazeFactory

class BombedMazeFactory : public MazeFactory {
public:
    BombedMazeFactory();
    virtual Wall* MakeWall() const;
    virtual Room* MakeRoom(int n) const;
};
Wall* BombedMazeFactory::MakeWall () const {
    return new BombedWall;
} 
Room* BombedMazeFactory::MakeRoom (int n) const {
    return new RoomWithABomb(n);
}注意這裡虛擬函式的重寫，沒有把Abstract中的所有虛擬函式都重寫，就重寫了需要改變的Room 和 Wall

同理是EnchantedMazeFactory的實現

class EnchantedMazeFactory : public MazeFactory {
public:
    EnchantedMazeFactory();
    virtual Room* MakeRoom(int n)  const;
    virtual Door* MakeDoor(Room* r1, Room* r2) const;
protected:
    Spell* CastSpell() const;
};
Room* EnchantedMazeFactory::MakeRoom(int n)  const
        { return new EnchantedRoom(n, CastSpell()); }
Door* EnchantedMazeFactory::MakeDoor(Room* r1, Room* r2)  const
        { return new DoorNeedingSpell(r1, r2); }

把上面這個放到CreateMaze（）中就是如下所示，注意我們完全沒有必要粉case討論，直接輸入AbstractFactory基類型別就可以,

Maze* MazeGame::CreateMaze (MazeFactory& factory) {
    Maze* aMaze = factory.MakeMaze();
    Room* r1 = factory.MakeRoom(1);
    Room* r2 = factory.MakeRoom(2);
    Door* aDoor = factory.MakeDoor(r1, r2);

    aMaze->AddRoom(r1);
    aMaze->AddRoom(r2);

    r1->SetSide(North, factory.MakeWall());
    r1->SetSide(East, aDoor);
    r1->SetSide(South, factory.MakeWall());
    r1->SetSide(West, factory.MakeWall());
 
    r2->SetSide(North, factory.MakeWall());
    r2->SetSide(East, factory.MakeWall());
    r2->SetSide(South, factory.MakeWall());
    r2->SetSide(West, aDoor);
    return aMaze;
}

然後想要建立哪種風格的Maze，就輸入相應的ConcreteFactory, 輸入進去了就可以形成多型，CreateMaze()裡面的程式碼就一行不用改了。建立程式碼如下

BombedMazeFactory  BFactory;
EnchantedMazeFactory EFactory;

Maze* pBMaze = MazeGame::CreateMaze(BFactory);
Maze* pEMaze = MazeGame::CreateMaze(EFactory);

所以，現在就知道了如何利用AbstractFactory來通過AbstractFactory派生到ConcreteFactroy的過程，就在這些類裡面封裝了我們所需要的變化，因此在CreateMaze裡面就可以用單一的程式碼動態的展現我們的多種風格Maze的生成，這就是模式的精華。 這個裡面還要注意的是，MazeFactory這個類裡面不含純虛擬函式，可以直接生成物件，所以他不是抽象類。 但是注意，我們這裡一旦選定了factory的種類，CreateMaze的任務比如AddRoom(), SetSide()還是在CreateMaze()方法中顯示完成的，就與接下來的Builder模式不一樣了，因為Builder模式把上面Room的具體實現形式都封裝到了Builder物件中了。

2.Builder模式

迷宮Builder的基類

class MazeBuilder {
public:
    virtual void BuildMaze() { }
    virtual void BuildRoom(int room) { }
    virtual void BuildDoor(int roomFrom, int roomTo) { }

    virtual Maze* GetMaze() { return 0; }
protected:
    MazeBuilder();
};

MazeGame中CreateMaze()方法重新定義如下

Maze* MazeGame::CreateMaze (MazeBuilder& builder)
 {
    builder.BuildMaze();

    builder.BuildRoom(1);
    builder.BuildRoom(2);
    builder.BuildDoor(1, 2);

    return builder.GetMaze();
}

對比與AbstractFactory模式，可以發現CreateMaze中所有的對Maze製造過程都只依賴builder物件，不需要對Maze物件直接操作，而是把對Maze物件的操作放到了Builder裡面的方法中完成。當我們具體定義一個Builder的時候，通常要把基類的Builder繼承，如派生一個StandardMazeBuilder

class StandardMazeBuilder : public MazeBuilder {
public:
    StandardMazeBuilder();
    
    virtual void BuildMaze();
    virtual void BuildRoom(int);
    virtual void BuildDoor(int, int);
    
     virtual Maze* GetMaze();
private:
    Direction CommonWall(Room*, Room*);
    Maze* _currentMaze;
};

下面看建造Maze的方法，本來是要呼叫Maze物件來完成，但是現在是被封裝到了Builder物件中了

StandardMazeBuilder::StandardMazeBuilder () {
    _currentMaze = 0;
}
void StandardMazeBuilder::BuildMaze () {
    _currentMaze = new Maze;
}
Maze *StandardMazeBuilder::GetMaze () {
    Maze* maze =  _currentMaze;
    return maze;
}
void StandardMazeBuilder::BuildRoom (int n) {
    if (!_currentMaze->RoomNo(n)) {
        Room* room = new Room(n);
        _currentMaze->AddRoom(room);
        
        room->SetSide(North, new Wall);
        room->SetSide(South, new Wall);
        room->SetSide(East, new Wall);
        room->SetSide(West, new Wall);
    }
}
void StandardMazeBuilder::BuildDoor (int n1, int n2) {
    Room* r1 = _currentMaze->RoomNo(n1);
    Room* r2 = _currentMaze->RoomNo(n2);
    Door* d = new Door(r1, r2);
    
    r1->SetSide(CommonWall(r1,r2), d);
    r2->SetSide(CommonWall(r2,r1), d);
}

這樣一來，在CreateMaze()方法中程式碼就更簡單了，這樣完全將Maze的構建和Maze物件可以隔離開來，單純用builder物件就可以完成了。同理，對於不同風格的Maze的建立，需要繼承不同種類的Builder. 而且，builder的基類也不是抽象類，因為裡面如果有純虛擬函式一定要被實現，而實際中builder的派生出來的conceate builder中差別比較大，不一定每個都會用到基類中的純虛擬函式, 所以就沒必要採用抽象類來作為基類。 最終，採用下面程式碼來實現一個maze物件

void Test1() {
Maze* maze;
MazeGame game;
StandardMazeBuilder builder;

game.CreateMaze(builder);
maze = builder.GetMaze();
}

最後總結一下AbstractFactroy和Builder的聯絡和區別： 1. 兩個基類都不是抽象類 2. Builder比Abstract的封裝更隱蔽