设计模式的思考（四）

 看看这些模式都解决了哪些问题：

创建模式（5个）：

// 创建一个个迷宫，某个地方将调用下面的代码

...
class Maze{
...
}
class Room{
...
}
class Door{
...
}
...
class Game{
...
//以下即为创建过程
   Maze CreateMaze(){
     Maze *aMaze=new Maze;//要修改
     Room *aRoom= new Room;//要修改
     Door *aDoor= new Door(aRoom);//要修改
   
     aMaze->AddRoom(aRoom);
   
     return aMaze;
  }
//以上即为创建过程
...
}
....
int  main(){
  ...
  Game *game=new Game();
  game->createMaze();
  ...
}

这段创建过程的代码的主要问题是不够灵活。如果改变了Room, Door这里的代码就要改变。比如说我们想把这个Room，改为EnchantedRoom呢？就要将第2行代码改掉，加入EnchantedRoom的定义。可能要考虑这里的实现逻辑，并添加新类。修改的地方太多。

工厂模式：想买一辆车或开发一辆新车，你肯定是找汽车制造厂，不会找服装厂。解决接口问题。

...
class Maze{
...
}
class Room{
...
}
class Door{
...
}
...
class Factory{
   ...
   Maze* makeMaze(){...};
   Room* makeRoom(){...};
   Door* makeDoor(){...};
   ...
}
//可以添加不同的工厂，每一个工厂可以制造不同的maze,room &door
//但是有可能要定义很多的类，但是采用工厂模式可以使得建造有统一的接口
clas Factory1:public Factory{
...
 Maze* makeMaze(){
    return new Maze();
 };
...
}
...
clas FactoryN:public Factory{
...
 Maze* makeMaze(){
    return new MazeN();
 };
...
}
//
 
class Game{
...
   Maze CreateMaze(){
     Factory *factory= new FactoryN();//可以修改，但是涉及到具体逻辑，且如果工厂很多，
                                    //有不同的风格他人难以使用，需要继续演化
     Maze *aMaze=factory->makeMaze();
     Room *aRoom=factory->makeRoom;
     Door *aDoor=factory->makeDoor(aRoom);
   
     aMaze->AddRoom(aRoom);
   
     return aMaze;
  }
...
 
}
....
 
int  main(){
  ...
  Game *game=new Game();
  game->createMaze();
  ...
}

可以定义新的方法来实现部件，而修改只有1处。

抽象工厂模式：当同类工厂比较多，比较复杂的时候，你要将他们继续分类和组合，一类工厂创建一类产品，抽象工厂就是总公司。一家人的衣服怎么收藏？假设有一个衣帽间，衣帽间里有3个衣橱，分别存爸爸的衣服，妈妈的，孩子的。解决风格问题。

...
class Maze{
...
}
class Room{
...
}
class Door{
...
}
...
class Factory{
   ...
   Maze* makeMaze(){...};
   Room* makeRoom(){...};
   Door* makeDoor(){...};
   ...
}
//可以添加不同的工厂，每一个工厂可以制造不同的maze,room &door
//但是有可能要定义很多的类，但是采用工厂模式可以使得建造有统一的接口
clas Factory1:public Factory{
...
 Maze* makeMaze(){
    return new Maze();
 };
...
}
...
clas FactoryN:public Factory{
...
 Maze* makeMaze(){
    return new MazeN();
 };
}
//抽象工厂将不同的风格进行了统一
class FactoryProducer{
  ...
  Factory getMazeFactory(){//可以修改
   //style1
     return factory1;
    .....
   //styleN
     return factoryN;
  }
  ...
}
class Game{
...
  Maze* CreateMaze(){
    Factory factory=FactoryProducer.getMazeFactory();
    Maze *aMaze=factory.makeMaze();
    Room *aRoom=factory.makeRoom;
    Door *aDoor=factory.makeDoor(aRoom);
   
    aMaze->AddRoom(aRoom);
   
    return aMaze;
  }
...
}
.....
int  main(){
  ...
  Game *game=new Game();
  game->createMaze();
  ...
}

单例模式：避免一个全局使用的类频繁地创建与销毁。比如GUI的画笔。FactoryProducer就可以采用单例。

class Singleton{
  ...
  static  Singleton Instance(){
    if(_instance==0){
       _instance=new Singleton();
    }
    return _instance;
  }
...
private；
 static Singleton * _instance;
  
}
...
Singleton:: _instance=0;

建造者模式：复杂对象的各个部分相对稳定，但是将它们组合在一起的算法却经常面临着剧烈的变化，但是又要统一管理，将稳定部分和非稳定部分分离，分别创建。建稳定部分与非稳定部分结合的是创建者。餐厅账单的项目是变化的，计算账单的总额方法是固定的。

...
class Maze{
...
}
class Room{
...
}
class Door{
...
}
...
class Factory{
   ...
   Maze* makeMaze(){...};
   Room* makeRoom(){...};
   Door* makeDoor(){...};
   ...
}
//可以添加不同的工厂，每一个工厂可以制造不同的maze,room &door
//但是有可能要定义很多的类，但是采用工厂模式可以使得建造有统一的接口
clas Factory1:public Factory{
...
}
...
clas FactoryN:public Factory{
...
}
//抽象工厂将不同的风格进行了统一
class FactoryProducer{
  ...
  Factory getMazeFactory(){//可以修改
   //style1
     return factory1;
    .....
   //styleN
     return factoryN;
  }
  ...
}
//新加入，可以采用统一的方式进行管理
class MazeBuilder{
     List itemList=new List