策略模式

1.使用场景：算法经常变化

2.基本思想：定义算法家族，分别封装起来，让它们之间可以互相替换，让算法的变化独立于算法的客户；

                    将行为委托给XXX代为处理　　　　　　

3.应用技术：多态 ，多用组合少用继承

4.实现代码：

Java:

//strategy java
abstract class Duck{

    public Duck(){}
    
    public abstract void display();
    
    public void performFly(){
        flyBehavior.fly();            //delegate to fly
    }
    
    public void performQuack(){
        quackBehavior.quack();        //delegate to quack
    }
    
    public void swim(){
        System.out.println("All ducks can swim.");
    }

    FlyBehavior   flyBehavior;      //fly
    QuackBehavior quackBehavior;    //quack
}

//MallardDuck
class MallardDuck extends Duck{
    public MallardDuck(){
        flyBehavior   = new FlyWithWings();
        quackBehavior = new Quack();
    }
    
    public MallardDuck(FlyBehavior fb,QuackBehavior qb){
        flyBehavior   = fb;
        quackBehavior = qb;
    }
    
    public void display(){
        System.out.println("I`m a real Mallard duck");
    }
}

//FlyBehavior
interface FlyBehavior{
    public void fly();
}

class FlyWithWings implements FlyBehavior{
    public void fly(){
        System.out.println("I`m flying!");
    }
}

class FlyNoWay implements FlyBehavior{
    public void fly(){
        System.out.println("I can`t fly!");
    }
}

//quack
interface QuackBehavior{
    public void quack();
}

class Quack implements QuackBehavior{
    public void quack(){
        System.out.println("Quack");
    }
}

class MuteQuack implements QuackBehavior{
    public void quack(){
        System.out.println("Silence");
    }
}

class Squack implements QuackBehavior{
    public void quack(){
        System.out.println("Squack");
    }
}

//main
public class DuckSimulator{
    public static void main(String[] args){
        //1
        Duck mallard_1 = new MallardDuck();
        mallard_1.performFly();
        mallard_1.performQuack();
        mallard_1.display();
        mallard_1.swim();
                
        //2
        FlyBehavior     fly = () -> System.out.println("\r\nflying...");
        QuackBehavior   quk = () -> System.out.println("quacking...");
        Duck mallard_2 = new MallardDuck(fly,quk);
        mallard_2.performFly();
        mallard_2.performQuack();
        
        //set fly
        mallard_2.flyBehavior = () -> System.out.println("\r\nstop flying...");
        mallard_2.performFly();
    }
}

 

 C++:

//strategy c++
#include <iostream>
#include <memory>
using namespace std;

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

class FlyWithWings : public FlyBehavior{
public:
    void fly(){
        cout<<"I`m flying!"<<endl;
    }
};

class FlyNoWay : public FlyBehavior{
public:
    void fly(){
        cout<<"I can`t fly!"<<endl;
    }
};

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

class Quack : public QuackBehavior{
public:
    void quack(){
        cout<<"Quack"<<endl;
    }
};

class MuteQuack : public QuackBehavior{
public:
    void quack(){
        cout<<"Silence"<<endl;
    }
};

//Duck
class Duck{

public:
    Duck(){};
    Duck(shared_ptr<FlyBehavior> pfb,shared_ptr<QuackBehavior> pqb) :
    m_pflyBehavior(pfb),
    m_pquackBehavior(pqb){};

    virtual void display() = 0;                             //pure virtual 不能实例化
    
    void setFlyBehavior(shared_ptr<FlyBehavior> pfb)        { m_pflyBehavior = pfb;  }
    void performFly()                                       { m_pflyBehavior->fly(); }
    
    void setQuackBehavior(shared_ptr<QuackBehavior> pqb)    { m_pquackBehavior = pqb;    }
    void performQuack()                                     { m_pquackBehavior->quack(); }
    
    void swim()                                             { cout<<"All ducks can swim."<<endl; }
    
private:
    shared_ptr<FlyBehavior>   m_pflyBehavior;   //fly
    shared_ptr<QuackBehavior> m_pquackBehavior; //quack
};

class MallardDuck : public Duck{

public:
    MallardDuck(){
        setFlyBehavior(make_shared<FlyWithWings>());
        setQuackBehavior(make_shared<Quack>());
    }

    MallardDuck(shared_ptr<FlyBehavior> fb,shared_ptr<QuackBehavior> pb) : Duck(fb,pb){}

    void display(){
        cout<<"I`m a real Mallard duck"<<endl;
    }
};

//main
int main()
{
    //mallard_1
    Duck* mallard_1 = new MallardDuck();
    mallard_1->performFly();
    mallard_1->performQuack();
    mallard_1->display();
    mallard_1->swim();
    
    //mallard_2
    cout<<"\r\nmallard_2:\r\n";
    auto fly = make_shared<FlyWithWings>();
    auto quk = make_shared<MuteQuack>();
    Duck* mallard_2 = new MallardDuck(fly,quk);
    mallard_2->performFly();
    mallard_2->performQuack();
    
    //set fly
    [](){cout<<"\r\nset fly:\r\n";}();
    mallard_2->setFlyBehavior(make_shared<FlyNoWay>());
    mallard_2->performFly();

    return 0;
}