设计模式学习之策略模式

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

有这样一个情景：

      游戏公司要开发一款游戏，希望游戏界面上有一些鸭子，鸭子具有他本身的一些行为，包括飞，叫，跑等等。

     于是我们这么设计，建立一个Duck接口，写几个飞，跑，叫的公共方法，那么接下来我们不同类的鸭子就实现这个接口，比如绿头鸭，草鸭等。这个就满足了该游戏的这个需求。后面发现，一些假的木头鸭也在屏幕上又飞又跑的，并且这时候游戏公司又提出，这些鸭子的行为要能够动态变化的，比如绿头鸭，有时嘎嘎叫，愤怒时是咆哮的叫等。

这时候我们原来的设计就无法满足了。于是我们想到了策略模式，将变化的部分提取出，分别封装起来，这时候我们有了如下的设计。

     

    代码目录图：

创建算法族（鸭子行为）：

package com.design.strategy;

public interface Fly {

	public void fly();
}

创建行为种类，木头鸭的行为是不能飞,于是有：

package com.design.strategy;

public class NoFlay implements Fly{

	public void fly() {
		System.out.println("I cann't fly");
	}


}

草头鸭飞的比较快，于是有：

package com.design.strategy;

public class QuickFly implements Fly{

	public void fly() {
		System.out.println("I am Fly Quickly");
	}

}

Duck接口（这边的接口指的是抽象类）：

package com.design.strategy;

public abstract class Duck {
	Fly fly;
	Quack quack;
	public void fly(){
		fly.fly();
	}
	
	public void Quack(){
		quack.quack();
	}
	
	public void swimming(){
		System.out.println("I am Swimming");
	}


	public void setNoQuack(Quack noQuack) {
		this.quack = noQuack;
	}

	public Fly getFly() {
		return fly;
	}

	public void setFly(Fly fly) {
		this.fly = fly;
	}

	public Quack getQuack() {
		return quack;
	}

	public void setQuack(Quack quack) {
		this.quack = quack;
	}

}

创建一只瘸腿鸭：

package com.design.strategy;

public class BadDuck extends Duck {

	public BadDuck(){
		fly = new NoFlay();
		quack = new NoQuack();
	}
	
}

我们做下测试：

package com.design.strategy;

public class StrategyTest {

	public static void main(String[] args) {
			Duck badDuck = new BadDuck();
			badDuck.fly();
	}

}

如果瘸腿鸭获救治好了，又可以飞了，那么就可以动态处理：

package com.design.strategy;

public class StrategyTest {

	public static void main(String[] args) {
			Duck badDuck = new BadDuck();
			badDuck.fly();
			badDuck.setFly(new QuickFly());
			badDuck.fly();
	}

}

测试结果：