Head First 之 策略模式

定义

策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

封装的飞行行为

//飞行行为接口类
class Flybehavior
{
public:
    Flybehavior(){}
    //删除基类，所以这里析构函数要用虚函数
    virtual ~Flybehavior(){}
    virtual void fly() = 0;
};

//具体的飞行类行为
class FlyWithWings :public Flybehavior
{
public:
    void fly()
    {
        qDebug()<< "Fly With Wings";
    }
};
//具体的飞行类行为
class FlyNoWay :public Flybehavior
{
public:
    void fly()
    {
        qDebug()<< "Fly No Way";
    }
};
//具体的飞行类行为
class FlyWithRock :public Flybehavior
{
public:
    void fly()
    {
        qDebug()<< "Fly With Rock";
    }
};

封装的呱呱叫行为

//呱呱叫行为接口类
class QuackBehavior
{
public:
    QuackBehavior(){}
    //删除基类，所以这里析构函数要用虚函数
    virtual ~QuackBehavior(){}
    virtual void quack() = 0;
};
//具体叫的行为类
class Quack:public QuackBehavior
{
public:
    void quack()
    {
        qDebug()<< "Quack";
    }
};
//具体叫的行为类
class Squeak:public QuackBehavior
{
public:
    void quack()
    {
        qDebug()<< "i can Squeak";
    }
};
//具体叫的行为类
class MuteQuack:public QuackBehavior
{
public:
    void quack()
    {
        qDebug()<< "Mute Quack";
    }
};

客户类

class Duck
{
public:
    Duck():quackBehavior(0),flybehavior(0){}
    void swim();
    void display();

    //行为接口
    void performQauck();
    void performFly();

    //替换算法接口
    void setQauckBehavior(QuackBehavior*);
    void setFlyBehavior(Flybehavior*);

protected:
    //使用组合方式，而不是继承
    QuackBehavior *quackBehavior;
    Flybehavior * flybehavior;
};

void Duck::performQauck()
{
    quackBehavior->quack();//委托给QuackBehavior类实现
}

void Duck::performFly()
{
    flybehavior->fly();//委托给Flybehavior类实现
}

void Duck::setQauckBehavior(QuackBehavior *q)
{
    if(quackBehavior)
        delete quackBehavior;//这里要求基类的析构函数是虚函数

    quackBehavior = q;
}

void Duck::setFlyBehavior(Flybehavior *f)
{
    if(flybehavior)
        delete flybehavior;

    flybehavior = f;
}

class MallardDuck :public Duck
{
public:
    MallardDuck()
    {
        quackBehavior = new Squeak();
        flybehavior = new FlyWithWings();
    }

    void swim()
    {
        qDebug() << "i am mallard duck ,i can swim";
    }
    void display()
    {
         qDebug() << "i am mallard duck";
    }
};

客户端代码

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //父类指针指向子类实例
    Duck *duck1 = new MallardDuck();

    //对接口编程
    duck1->performFly();
    duck1->performQauck();
    duck1->setFlyBehavior(new FlyWithRock);
    duck1->performFly();
    duck1->performFly();

    return a.exec();
}

静态类图

设计原则

• 多用组合，少用继承
• 针对接口编程，而不是针对实现编程（针对超类的编程）
• 找出应用中可能需要变化之处，把它们独立出来，不要和那些不要变化的代码混在一起