根据所传参数对象的不同而产生不同行为的方法，称为策略模式。这类方法包含所要执行的算法中固定不变的部分，而“策略”包含变化的部分。策略就是传递进去的参数对象，它包含要执行的代码。
策略模式是对象的行为模式，用意是对一组算法进行封装。动态的选择需要的算法并使用。
其UML图如下：
其组成部分如下：
Ø 环境角色（Context）：用来持有一个策略基类的引用（Strategy strategy）。
Ø 抽象策略（<Interface> Stratege）：用来定义一组操作，通常是一个借口，或抽象类。
Ø 具体策略（ConcreteStratege）：具体的实现类。
策略设计模式的优点：
Ø 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。
Ø 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。
Ø 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
策略模式的缺点：
Ø 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。
模式定义
把会变化的内容取出并封装起来，以便以后可以轻易地改动或扩充部分，而不影响不需要变化的其他部分。
问题缘起
当涉及到代码维护时，为了复用目的而使用继承，结局并不完美。对父类的修改，会影响到子类型。在超类中增加的方法，会导致子类型有该方法，甚至连那些不该具备该方法的子类型也无法免除。
下面是策略模式的一个典型例子（duck）：
public abstract class Duck {
// 所有的鸭子均会叫以及游泳，所以父类中处理这部分代码
public void quack() {
System.out.println("Quack");
}
public void swim() {
System.out.println("All ducks float, even decoys.");
}
// 因为每种鸭子的外观是不同的，所以父类中该方法是抽象的，由子类型自己完成。
public abstract void display();
}
public class MallardDuck extends Duck {
// 野鸭外观显示为绿头
public void display() {
System.out.println("Green head.");
}
}
public class RedHeadDuck extends Duck {
// 红头鸭显示为红头
public void display() {
System.out.println("Red head.");
}
}public class RubberDuck extends Duck {
// 橡皮鸭叫声为吱吱叫，所以重写父类以改写行为
public void quack() {
System.out.println("Squeak");
}
// 橡皮鸭显示为黄头
public void display() {
System.out.println("Yellow head.");
}
}
上述代码，初始实现得非常好。现在我们如果给Duck.java中加入fly()方法的话，那么在子类型中均有了该方法，于是我们看到了会飞的橡皮鸭子，你看过吗？当然，我们可以在子类中通过空实现重写该方法以解决该方法对于子类型的影响。但是父类中再增加其它的方法呢？通过继承在父类中提供行为，会导致以下缺点：
Ø 代码在多个子类中重复;
Ø 运行时的行为不容易改变；
Ø 改变会牵一发而动全身，造成部分子类型不想要的改变；
好啦，还是刚才鸭子的例子，你也许想到使用接口，将飞的行为、叫的行为定义为接口，然后让Duck的各种子类型实现这些接口。这时侯代码类似于：
public abstract class Duck {
// 将变化的行为 fly() 以及quake()从Duck类中分离出去定义形成接口，有需求的子类中自行去实现
public void swim() {
System.out.println("All ducks float, even decoys.");
}
public abstract void display();
}
//变化的 fly() 行为定义形成的接口
public interface FlyBehavior {
void fly();
}
//变化的 quack() 行为定义形成的接口
public interface QuackBehavior {
void quack();
}
//野鸭子会飞以及叫，所以实现接口 FlyBehavior, QuackBehavior
public class MallardDuck extends Duck implements FlyBehavior, QuackBehavior {
public void display() {
System.out.println("Green head.");
}
public void fly() {
System.out.println("Fly.");
}
public void quack() {
System.out.println("Quack.");
}
}
//红头鸭子会飞以及叫，所以也实现接口 FlyBehavior, QuackBehavior
public class RedHeadDuck extends Duck implements FlyBehavior, QuackBehavior {
public void display() {
System.out.println("Red head.");
}
public void fly() {
System.out.println("Fly.");
}
public void quack() {
System.out.println("Quack.");
}
}//橡皮鸭不会飞，但会吱吱叫，所以只实现接口QuackBehavior
public class RubberDuck extends Duck implements QuackBehavior {
// 橡皮鸭叫声为吱吱叫
public void quack() {
System.out.println("Squeak");
}
// 橡皮鸭显示为黄头
public void display() {
System.out.println("Yellow head.");
}
}上述代码虽然解决了一部分问题，让子类型可以有选择地实现一些行为(例如 fly() 方法将不会出现在橡皮鸭中)。但我们也看到，野鸭子MallardDuck.java和红头鸭子RedHeadDuck.java的一些相同行为代码不能得到重复使用。很大程度上这是从一个火坑跳到另一个火坑。
我们知道，继承在某种程度上可以实现代码重用，但是父类(例如鸭子类Duck)的行为在子类型中是不断变化的，让所有子类型都有这些行为是不恰当的。我们可以将这些行为定义为接口，让Duck的各种子类型去实现，但接口不具有实现代码，所以实现接口无法达到代码复用。这意味着，当我们需要修改某个行为，必须往下追踪并在每一个定义此行为的类中修改它，一不小心，会造成新的错误。
设计原则：把应用中变化的地方独立出来，不要和那些不需要变化的代码混在一起。这样代码变化引起的不经意后果变少，系统变得更有弹性。
按照上述设计原则，我们重新审视之前的Duck代码：
Ø 分开变化的内容和不变的内容
Duck类中的行为 fly(), quack(), 每个子类型可能有自己特有的表现，这就是所谓的变化的内容。Duck类中的行为 swim() 每个子类型的表现均相同，这就是所谓不变的内容。我们将变化的内容从Duck()类中剥离出来单独定义形成接口以及一系列的实现类型，这样就可以实现变化内容和不变内容的剥离，其变化内容的子类型可以实现变化内容的重用。这些实现类并非Duck.java的子类型，而是专门的一组实现类，称之为"行为类"。由行为类而不是Duck.java的子类型来实现接口。这样，才能保证变化的行为独立于不变的内容。于是我们有：
Ø 变化的内容：
//变化的 fly() 行为定义形成的接口
public interface FlyBehavior {
void fly();
}
//变化的 fly() 行为的实现类之一
public class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("I'm flying.");
}
}
//变化的 fly() 行为的实现类之二
public class FlyNoWay implements FlyBehavior {
public void fly() {
System.out.println("I can't fly.");
}
}
//变化的 quack() 行为定义形成的接口
public interface QuackBehavior {
void quack();
}
//变化的 quack() 行为实现类之一
public class Quack implements QuackBehavior {
public void quack() {
System.out.println("Quack");
}
}
//变化的 quack() 行为实现类之二
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println("Squeak.");
}
}//变化的 quack() 行为实现类之三
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println("<< Slience >>");
}
}
通过以上设计，fly()行为以及quack()行为已经和Duck.java没有什么关系，可以充分得到复用。而且我们很容易增加新的行为, 既不影响现有的行为，也不影响Duck.java。但是，大家可能有个疑问，就是在面向对象中行为不是体现为方法吗？为什么现在被定义形成类(例如Squeak.java)？在面向对象设计中，类代表的"东西"一般是既有状态(实例变量）又有方法的，只是在本例中碰巧"东西"是个行为。既使是行为，也可以有属性及方法，例如飞行行为，也需要一些属性记录飞行的状态，如飞行高度、速度等。
v 整合变化的内容和不变的内容
Duck.java将 fly()以及quack()的行为委拖给行为类处理。
Ø 不变的内容：
public abstract class Duck {
// 将行为类声明为接口类型，降低对行为实现类型的依赖
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void performFly() {
// 不自行处理fly()行为，而是委拖给引用flyBehavior所指向的行为对象
flyBehavior.fly();
}
public void performQuack() {
quackBehavior.quack();
}
public void swim() {
System.out.println("All ducks float, even decoys.");
}
public abstract void display();
}//野鸭子会飞以及叫，所以实现接口 FlyBehavior, QuackBehavior
public class MallardDuck extends Duck {
public MallardDuck() {
flyBehavior = new FlyWithWings();
quackBehavior = new Quack();
}
public void display() {
System.out.println("Green head.");
}
}
public class DuckTest {
public static void main(String[] args) {
Duck duck = new MallardDuck();
duck.performFly();
duck.performQuack();
}
}
Ø 我们可以通过工厂模式或其它模式进一步解藕;
Ø 或做到在运行时动态地改变行为。
v 动态设定行为
在父类Duck.java中增加设定行为类型的set方法，接受行为类型对象的参数传入。为了降藕，行为参数被声明为接口类型。这样，既便在运行时，也可以通过调用这二个方法以改变行为。
public abstract class Duck {
// 将行为类声明为接口类型，降低对行为实现类型的依赖
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void performFly() {
// 不自行处理fly()行为，而是委拖给引用flyBehavior所指向的行为对象
flyBehavior.fly();
}
public void performQuack() {
quackBehavior.quack();
}
public void swim() {
System.out.println("All ducks float, even decoys.");
}
public abstract void display();
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}public class DuckTest {
public static void main(String[] args) {
Duck duck = new MallardDuck();
duck.performFly();
duck.performQuack();
duck.setFlyBehavior(new FlyNoWay());
duck.performFly();
}
}如果，我们要加上火箭助力的飞行行为，只需再新建FlyBehavior.java接口的实现类型。而子类型可通过调用setQuackBehavior(...)方法动态改变。至此，在Duck.java增加新的行为给我们代码所带来的困绕已不复存在。
3. 解决方案
MallardDuck 继承 Duck抽象类； -> 不变的内容
FlyWithWings 实现 FlyBehavior接口； -> 变化的内容,行为或算法
在Duck.java提供setter方法以装配关系； -> 动态设定行为
以上就是策略模式的实现三步曲。接下来，让我们透过步骤看本质:
1) 初始，我们通过继承实现行为的重用，导致了代码的维护问题。 -> 继承
2) 接着，我们将行为剥离成单独的类型并声明为不变内容的实例变量并通过 -> 组合
继承，可以实现静态代码的复用；组合，可以实现代码的弹性维护；使用组合代替继承，可以使代码更好地适应软件开发完后的需求变化。
策略模式的本质：少用继承，多用组合。
29万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
