设计模式读书笔记（一） Abstract Factory（抽象工厂）模式

一段时间没上博客了，总觉得各种忙，也不知道在忙些啥，瞎忙活的感觉，仔细想了一下，还是每天抽时间出来好好看看书，在博客上记录一下自己的成长过程。闲话不多说了，开始吧~~

先简单的介绍一下一般的设计模式包含哪些，还有他们的目的是什么吧：

目的	设计模式	可改变的方面
创建	Abstract Factory	产品对象家族
	Builder	如何创建一个组合对象
	Factory Method	被实例化的子类
	Prototype	被实例化的类
	Singleton	一个类的唯一实例
结构	Adapter	对象的接口
	Bridge	对象的实现
	Composite	一个对象的结构和组成
	Decorator	对象的职责，不生成子类
	Facade	一个子系统的接口
	Flyweight	对象的储存开销
	Proxy	如何访问一个对象；该对象的位置
行为	Chain of Responsibility	满足一个请求的对象
	Command	何时，怎样满足一个请求
	Interpreter	一个语言的文法及解释
	Iterator	如何遍历，访问一个聚合的各个元素
	Mediator	对象间如何交互，和谁交互
	Memento	一个对象中哪些私有信息存放在该对象之外，以及在什么时候储存
	Observer	多个对象依赖于另一个对象，而这些对象如何保持一致
	State	对象的状态
	Strategy	算法
	Template Method	算法中的某些步骤
	Visitor	某些可作用于一个(组)对象上的操作，但不修改这些对象的类

一、抽象工厂的介绍

Abstract Factory—抽象工厂，是一种对象创建型的模式，它的意图是提供一个可以创建一系列相关或互相依赖对象的接口，而无须指定它们具体的类。

二、适用性

• 一个系统要独立于它的产品创建和组合
• 一个系统中多个产品需要根据配置来选择
• 当你提供一个产品类库，而只是想显示他们的接口而不是实现的时候

三、结构图

四、代码例子

假设我们现在需要建立一个RPG游戏，玩家在开始的时候选择角色职业：Knight(骑士)，Assassin(刺客)，每个职业有自己的武器Weapon。

现在我们可以先定义抽象产品：

class Character
{
public:
    Character(){};
    ~Character(){if(m_Weapon) delete m_Weapon;};
    virtural void Speak(){};
    Weapon *m_Weapon;
}

class Weapon
{
public:
    Weapon(){};
    ~Weapon(){};
    virtual void SetDamage(int damage){};
}

接下来我们定义实体产品：

class Knight:public Character
{
public:
    Knight(){};
    ~Knight(){}
    void Speak()
    {
        cout<<"I am Knight!"<<endl;
    }
}

class Assassin:public Character
{
public:
    Assassin(){};
    ~Assassin(){}
    void Speak()
    {
        cout<<"I am Assassin!"<<endl;
    }

}

class Sword:public Weapon
{
public:
    Sword(){};
    ~Sword(){};
    void SetDamage(int d)
    {
        m_Damage = d;
        cout<<"Sword"<<endl;
    }
private:
    int m_Damage;
}

class Knife:public Weapon
{
public:
    Knife(){};
    ~Knife(){};
    void SetDamage(int d)
    {
        m_Damage = d;
        cout<<"Knife"<<endl;
    }
private:
    int m_Damage;
}

下面我们定义抽象工厂类

class PlayerCreator
{
public:
    PlayerCreator(){};
    ~PlayerCreator(){};
    virtural Character *CreateCharacter(){};
    virtural Weapon *CreateWeapon(){};

}

接下来定义实体工厂类：

class KnightCreator:public PlayerCreator
{
public:
    KnightCreator(){};
    ~KnightCreator(){};
    virtural Character *CreateCharacter()
    {
        return new Knight();
    }
    virtural Weapon *CreateWeapon()
    {
        Weapon *p = new Sword();
        p->SetDamage(5);
        return p;
    }
}

class AssassinCreator:public PlayerCreator
{
public:
    AssassinCreator(){};
    ~AssassinCreator(){};
    virtural Character *CreateCharacter()
    {
        return new Assassin();
    }
    virtural Weapon *CreateWeapon()
    {
        Weapon *p = new Knife();
        p->SetDamage(2);
        return p;
    }
}

下面是客户端调用：

enum PlayerType
{
    Knight = 0,
    Assassin=1
}
int main()
{
    PlayerType type;
    PlayerCreator *creator = NULL;
    Character *character = NULL;
    Weapon *weapon = NULL;
    if(type == PlayerType::Knight)
    {
        creator = new KnightCreator();
    }
    else
    {
        creator = new AssassinCreator();
    }

    character = creator->CreateCharactor();
    weapon = creator->CreateWeapon();
    character->Speak();
    character->m_Weapon = weapon;
}

PS:以上代码未经测试，全凭感觉写，如有错误之处，请指出，谢谢~

五、总结

1. 抽象工厂分离了具体的类
2. 易于产品的交换
3. 有利于实现产品的一致性
4. 难以支持新种类的产品，如果新产品接口属性不一样，需要改变较多