Strategy策略模式

设计模式解读之一： 策略模式
1. 模式定义
把会变化的内容取出并封装起来，以便以后可以轻易地改动或扩充部分，而不影响不需要变化的其他部分；
2. 问题缘起
当涉及至代码维护时，为了复用目的而使用继承，结局并不完美。对父类的修改，会影响到子类型。在超类
中增加的方法，会导致子类型有该方法，甚至连那些不该具备该方法的子类型也无法免除。


  (可重用但不灵活): 我们知道，继承在某种程度上可以实现"代码重用"，但是父类(例如鸭子类Duck)的行为在子类型中是不断变化
的，让所有子类型都有这些行为是不恰当的。
  (灵活但不可重用):我们可以将这些行为定义为接口，让Duck的各种子类型去实现，但接口不具有实现代码，所以实现接口无法达到代码复用。
这意味着，当我们需要修改某个行为，必须往下追踪并在每一个定义此行为的类中修改它，一不小心，会造成新的错误。
  
   设计原则：把应用中变化的地方独立出来，不要和那些不需要变化的代码混在一起。这样代码变化引起的不
经意后果变少，系统变得更有弹性。

1) 分开变化的内容和不变的内容：
Duck类中的行为 fly(), quack(), 每个子类型可能有自己特有的表现，这就是所谓的变化的内容。
Duck类中的行为 swim() 每个子类型的表现均相同，这就是所谓不变的内容。
2) 整合变化的内容和不变的内容：
Duck.java将 fly()以及quack()的行为委拖给行为类处理(行为类就是一些实现了fly()接口的类)。
Duck.java不关心如何进行 fly()以及quack(), 这些细节交由具体的行为类完成。
我们将变化的内容从Duck()类中剥离出来单独定义形成接口以及一系列的实现类型。将变化的内容定义形
成接口可实现变化内容和不变内容的剥离。其实现类型可实现变化内容的重用。这些实现类并非Duck.java的子
类型，而是专门的一组实现类，称之为"行为类"。由行为类而不是Duck.java的子类型来实现接口。这样，才能
保证变化的行为独立于不变的内容。


每种鸭子飞行和叫的方式不同，所以将这2部分独立出来：

飞的行为定义为接口

package com.wlh.strategy;

//变化的 fly() 行为定义形成的接口
public interface FlyBehavior {
	void fly();
	}

实现了接口FlyBehavior的行为类FlyNoWay：

package com.wlh.strategy;

//变化的 fly() 行为的实现类之二
public class FlyNoWay implements FlyBehavior {
	public void fly() {
	System.out.println("I can't fly.");
	}
	}

实现了接口FlyBehavior的行为类FlyWithWings：

package com.wlh.strategy;

//变化的 fly() 行为的实现类之一
public class FlyWithWings implements FlyBehavior {
	public void fly() {
	System.out.println("I'm flying.");
	}
	}

将叫这种行为定义为接口

package com.wlh.strategy;

//变化的 quack() 行为定义形成的接口
public interface QuackBehavior {
void quack();
}

实现了接口QuackBehavior 的一个行为类Quack :

package com.wlh.strategy;

//变化的 quack() 行为实现类之一
public class Quack implements QuackBehavior {
	public void quack() {
		System.out.println("Quack");
	}
}

实现了接口QuackBehavior 的一个行为类Squeak :

package com.wlh.strategy;

//变化的 quack() 行为实现类之二
public class Squeak implements QuackBehavior {
	public void quack() {
		System.out.println("Squeak.");
	}
}

实现了接口QuackBehavior 的一个行为类MuteQuack :

package com.wlh.strategy;

//变化的 quack() 行为实现类之三
public class MuteQuack implements QuackBehavior {
	public void quack() {
		System.out.println("<< Slience >>");
	}
}

下面是鸭子类(抽象类)，正如上面，它已经将变化的部分抽象为接口FlyBehavior和QuackBehavior，剩下的是不变的部分swim和未实现的方法display;

package com.wlh.strategy;

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 = new FlyWithWings(); //可变的部分
quackBehavior = new Quack();    //可变的部分
面向接口编程，将各种接口实现类的实例赋给接口变量，从而达到代码“复用性”；如果现实中这些实现还不能达到满足，我们可以增加对接口的实现类，比如鸭子不是用翅膀飞，那我们可以让它抱着火箭筒上天，随时增加和改变实现，直达满意位置，这又达到了代码的“灵活性”；不变的部分从Duck中继承过来

package com.wlh.strategy;

public class MallardDuck extends Duck {
	public MallardDuck() {
       //面向接口编程，将各种实现的实例赋给接口变量，达到复用这些行为的实现
	flyBehavior = new FlyWithWings(); //可变的部分
	quackBehavior = new Quack();    //可变的部分
	}

	public void display() {//不变的部分
		System.out.println("Green head.");
	}
}

测试：

package com.wlh.strategy.test;

import com.wlh.strategy.Duck;
import com.wlh.strategy.MallardDuck;

public class DuckTest {
	public static void main(String[] args) {
	Duck duck=new MallardDuck();
	duck.performFly();
	duck.performQuack();
	}
	}

输出：

I'm flying. 
Quack

评论

1 楼 carfily 2009-06-02  

学习了，谢谢