Head First策略模式qt

类图

定义

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

优缺点

优点：

1、 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码转移到父类里面，从而避免重复的代码。

2、 策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。

3、 使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。

缺点：

1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

2、 策略模式造成很多的策略类，每个具体策略类都会产生一个新类。有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。换言之，可以使用享元模式来减少对象的数量。

设计原则

1、 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。这个概念很简单，几乎是每个设计模式背后的精神所在，所有的模式都提供了一套方法让系统中的某部分改变不会影响其它部分。（分开变化和不变化的部分）

2、 针对接口编程，而不是针对实现编程。

3、 多用组合，少用继承（使用组合建立系统具有很大的弹性，不仅可将算法族封装成类，更可以在运行时动态地改变行为。）

代码

DUNK类：

#ifndef DUNK_H
#define DUNK_H

#include "flybehavior.h"
#include "quackbehavior.h"

class Duck
{
public:
    Duck();
    virtual void diaplay();
    void performFly();
    void perfomrQuack();
    void swim();
    void setFlyBehavior(FlyBehavior *fb);
    void setQuackBehavior(QuackBehavior *qb);

    FlyBehavior *flyBehavior;
    QuackBehavior *quackBehavior;
};

class MallardDuck : public Duck
{
public:
    MallardDuck();
    void diaplay() override;
};

class ModeDuck : public Duck
{
public:
    ModeDuck();
    void diaplay() override;
};

class DuckCall : public Duck
{
public:
    DuckCall();
    void diaplay() override;
};

#endif // DUNK_H

#include "duck.h"

Duck::Duck()
{

}

void Duck::diaplay()
{

}

void Duck::performFly()
{
    flyBehavior->fly();
}

void Duck::perfomrQuack()
{
    quackBehavior->quack();
}

void Duck::swim()
{
    qDebug() << "All ducks float, even decoys!";
}

void Duck::setFlyBehavior(FlyBehavior *fb)
{
    flyBehavior = fb;
}

void Duck::setQuackBehavior(QuackBehavior *qb)
{
    quackBehavior = qb;

}

MallardDuck::MallardDuck()
{
    quackBehavior = new Quack();
    flyBehavior = new FlyWithWings();
}

void MallardDuck::diaplay()
{
   qDebug() << "I'm a real Mallard duck";
}

ModeDuck::ModeDuck()
{
    flyBehavior = new FlyNoWay();
    quackBehavior = new Quack();
}

void ModeDuck::diaplay()
{
    qDebug() << "I'm a model duck";
}

DuckCall::DuckCall()
{
    flyBehavior = new FlyNoWay();
    quackBehavior = new Quack();
}

void DuckCall::diaplay()
{
    qDebug() << "I'm a DuckCall";
}

FlyBehavior类：

#ifndef FLYBEHAVIOR_H
#define FLYBEHAVIOR_H

#include <QDebug>

class FlyBehavior
{
public:
    virtual void fly() = 0;

    virtual ~FlyBehavior() {};
};

class FlyWithWings : public FlyBehavior
{
public:
    void fly() override;
};

class FlyNoWay : public FlyBehavior
{
public:
    void fly() override;
};

class FlyRocketPowered : public FlyBehavior
{
public:
    void fly() override;
};

#endif // FLYBEHAVIOR_H

#include "flybehavior.h"

void FlyWithWings::fly()
{
    qDebug() << "I'm flying!";
}

void FlyNoWay::fly()
{
    qDebug() << "I can't fly!";
}

void FlyRocketPowered::fly()
{
    qDebug() << "I'm flying with a rocket";
}

QuackBehavior类：

#ifndef QUACKBEHAVIOR_H
#define QUACKBEHAVIOR_H


#include <QDebug>

class QuackBehavior
{
public:
    virtual void quack() = 0;

    virtual ~QuackBehavior() {};
};

class MuteQuack : public QuackBehavior
{
public:
    void quack() override;
};

class Quack : public QuackBehavior
{
public:
    void quack() override;
};

class Squeak : public QuackBehavior
{
public:
    void quack() override;
};

#endif // QUACKBEHAVIOR_H

#include "quackbehavior.h"

void Quack::quack()
{
    qDebug() << "quack";
}

void MuteQuack::quack()
{
    qDebug() << "silence";
}

void Squeak::quack()
{
    qDebug() << "Squeak";
}

测试：

#include "mainwindow.h"
#include "duck.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    Duck *mallard = new MallardDuck();
    mallard->perfomrQuack();
    mallard->performFly();


    Duck *model = new ModeDuck();
    model->performFly();
    model->setFlyBehavior(new FlyRocketPowered());
    model->performFly();

    Duck *duckcall = new DuckCall();
    duckcall->perfomrQuack();
    duckcall->setQuackBehavior(new Squeak());
    duckcall->perfomrQuack();
}

MainWindow::~MainWindow()
{
}