设计模式之策略模式

策略模式

策略模式属于对算法的包装，使算法和算法本身分割开，派给不同的对象进行不同的操作管理，策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。

介绍

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。
　　这个模式涉及到三个角色：

●　　环境(Context)角色：持有一个Strategy的引用。

●　　抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

●　　具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

我们来举一个简单的例子
飞行和叫是两种行为，我们将飞行分为可以飞，不可以飞，坐火箭飞三种，三种具体实现类都实现了飞行这个行为，只是方式不同，所以我们用三个类继承飞行这个接口。鸭子分为可以叫和不能叫，我们在用两个叫声类实现叫这个行为的接口

package strategy_pattern.behavior;

public interface FlyBehavior {
    void Fly();
}

package strategy_pattern.behavior;

public class FlyWithWings implements FlyBehavior {
    public void Fly()
    {
        System.out.println("I can fly");
    }
}

package strategy_pattern.behavior;

public class FlyRocketPowered implements FlyBehavior {
    public void Fly()
    {
        System.out.println("I am flying with a rocket");
    }
}

package strategy_pattern.behavior;

public class FlyNoWay implements FlyBehavior {
    public void Fly()
    {
        System.out.println("I can not fly");
    }
}

package strategy_pattern.behavior;

public interface Quackbehavior {
    void Quack();
}

package strategy_pattern.behavior;

public class Quack implements Quackbehavior {

    @Override
    public void Quack() {
        System.out.println("Quack");
    }
}

package strategy_pattern.behavior;

public class Squeak implements Quackbehavior {
    public void Quack() {
        System.out.println("Squeak");
    }
}

然后我们再以鸭子为例，野鸭可以飞，玩具鸭不可以飞，玩具鸭也可以坐火箭飞。
我们用鸭子来举例，假设所有的鸭子拥有这两个行为。

package strategy_pattern.duck;

import strategy_pattern.behavior.FlyBehavior;
import strategy_pattern.behavior.Quackbehavior;

public class Duck {
    Quackbehavior quackbehavior;  
    FlyBehavior flyBehavior; //每只鸭子都实现这个对象

    public Duck () {
        
    }
    public void performFly()
    {
        flyBehavior.Fly();
    }

    public void performQuack()
    {
        quackbehavior.Quack();  //鸭子对象不亲自处理呱呱叫行为，而是委托给quackbehavior引用的对象
    }
}

这个是一只野鸭，继承了鸭子类，实现了其中的squeak和FlyWithWings

package strategy_pattern.duck;

import strategy_pattern.behavior.FlyWithWings;
import strategy_pattern.behavior.Squeak;

public class MallardDuck extends Duck {

    public MallardDuck()
    {
        System.out.println("I am MallarDuck...");
        quackbehavior=new Squeak();
         flyBehavior=new FlyWithWings();
    }
}

这是一只玩具鸭，实现了其中的FlyNoWay和Quack

package strategy_pattern.duck;

import strategy_pattern.behavior.FlyNoWay;
import strategy_pattern.behavior.Quack;

public class ModelDuck extends Duck {
    public ModelDuck()
    {
        System.out.println("I am ModelDuck...");
        flyBehavior=new FlyNoWay();
        quackbehavior=new Quack();
    }
}

package strategy_pattern;

import strategy_pattern.duck.Duck;
import strategy_pattern.duck.MallardDuck;
import strategy_pattern.duck.ModelDuck;

public class MiniDuckSimulator {
    public static void main (String []args)
    {
        Duck mallard=new MallardDuck();
        mallard.performQuack();
        mallard.performFly();
        Duck model=new ModelDuck();
        model.performFly();
        model.performQuack();
    }
}

这就是设计模式中的策略模式。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。