设计模式学习--策略模式（Strategy Pattern)

设计模式学习--策略模式（Strategy Pattern)

什么是策略模式？

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

怎么使用策略模式设计程序？

分开变化和不会变化的部分，建立一组新的类来代表变化的部分。

三个设计原则：

1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

2. 针对接口编程，而不是针对实现编程。

3. 多用组合，少用继承。

策略模式应用例子：

一只鸭Duck，可能是以下几种不同类型的鸭

(MallardDuck) 绿头鸭--会飞会呱呱叫

(RedHeadDuck) 红头鸭--会飞会呱呱叫

(RubberDuck) 橡皮鸭--不会飞会叽叽叫

(DecoyDuck) 诱饵鸭--不会飞也不会叫

(ModelDuck) 模型鸭--不会飞也不会叫

在没有使用策略模式之前可能这样：

1. 利用继承来提供Duck的行为

===》导致代码在多个子类中重复

===》运行时的行为不容易改变

===》很难知道所有鸭子的全部行为

===》改变会牵一发动全身，造成其他鸭子不想要的改变。

2. 把会变的行为提取出来设计成一个接口

===》导致重复代码变多

===》导致代码无法进行复用

使用策略模式会是这样：

1. 采用良好的oo软件设计原则

2. 分开变化和不会变化的部分

3. 针对接口编程

具体实现：

所有类型鸭的抽象：Duck类

package strategyPattern;

/**
 * 所有类型鸭子的超类
 * @author wwj
 *
 */
public abstract class Duck {
	FlyBehavior flyBehavior;		//飞行行为
	QuackBehavior quackBehavior;	//呱呱叫行为
	
	public void performQuack(){
		quackBehavior.quack();
	}
	
	public void swim(){
		System.out.println("All ducks float, even decoys!");
	}
	
	public abstract void display();
	
	public void performFly() {
		flyBehavior.fly();
	}
	
	public void setFlyBehavior(FlyBehavior fb) {
		flyBehavior = fb;
	}
	
	public void setQuackBehavior(QuackBehavior qb) {
		quackBehavior = qb;
	}
	
}

把会变化的部分取出并“封装”起来，好让其他部分不会受到影响

提供两个接口FlyBehavior和QuackBehavior

package strategyPattern;

public interface FlyBehavior {
	public void fly();
}

package strategyPattern;

public interface QuackBehavior {
	public void quack();
}

实现鸭子的行为（飞行类）

package strategyPattern;

public class FlyWithWings implements FlyBehavior {

	@Override
	public void fly() {
		//实现鸭子飞行
		System.out.println("I'm flying!");
	}

}

package strategyPattern;

public class FlyNoWay implements FlyBehavior {

	@Override
	public void fly() {
		//什么都不做，不会飞
		System.out.println("I can't fly");
	}

}

public class FlyRocketPowered implements FlyBehavior {
	
	@Override
	public void fly() {
		System.out.println("I'm flying with a rocket!");
	}

}

实现鸭子的行为（呱呱叫）

package strategyPattern;

public class Quack implements QuackBehavior {

	@Override
	public void quack() {
		//实现鸭子呱呱叫
		System.out.println("Quack");
	}

}

package strategyPattern;

public class Squack implements QuackBehavior {

	@Override
	public void quack() {
		//橡皮鸭子叽叽叫
		System.out.println("Squack");
	}

}

package strategyPattern;

public class MuteQuack implements QuackBehavior {

	@Override
	public void quack() {
		// 什么都不做，不会叫
	}

}

整合鸭子的行为，让不同的鸭子继承鸭类（Duck）

package strategyPattern;

/**
 * 绿头鸭继承鸭类
 * @author wwj
 *
 */
public class MallardDuck extends Duck{
	
	/**
	 * 因为MallardDuck继承Duck类，所以具有flyBehavior与quackBehavior实例变量
	 */
	public MallardDuck() {
		quackBehavior = new Quack(); //真正的呱呱叫	
		flyBehavior = new FlyWithWings();	//会用翅膀飞
	}
	
	public void display() {
		System.out.println("I'm a real Mallard duck");	//我是一个真正的绿头鸭
	}
	
}

package strategyPattern;

public class RedheadDuck extends Duck{
	public RedheadDuck() {
		flyBehavior = new FlyWithWings();
		quackBehavior = new Quack();
	}
	
	@Override
	public void display() {
		System.out.println("I'm a RedheadDuck!!");	//红头鸭
	}

}

package strategyPattern;

public class RubberDuck extends Duck{
	public RubberDuck() {
	}

	@Override
	public void display() {
		System.out.println("I'm a RubberDuck!!!");
	}

}

package strategyPattern;

public class ModelDuck extends Duck {
	public ModelDuck() {
		flyBehavior = new FlyNoWay();	//不会飞
		quackBehavior = new Quack();	//会叽叽叫
	}
	
	@Override
	public void display() {
		System.out.println("I'm a model duck");
	}

}

package strategyPattern;

public class DecoyDuck extends Duck{
	public DecoyDuck(){
	}

	@Override
	public void display() {
		System.out.println("I'm a DecoyDuck!!!");	//我是一只诱饵鸭
	}
	
}

测试类：

package strategyPattern;

public class MiniDuckSimulator {
	public static void main(String[] args) {
		Duck mallard = new MallardDuck();
		mallard.performQuack();
		mallard.performFly();
		
		
		//动态改变模型鸭的行为--通过调用继承来的setter方法
		Duck model = new ModelDuck();
		model.performFly();
		model.setFlyBehavior(new FlyRocketPowered());	//委托
		model.performFly();
	}
}

测试结果：

Quack
I'm flying!
I can't fly
I'm flying with a rocket!

确实，使用策略模式之后，代码变得可复用了，可以适应更多的变化，而不会互相影响。良好的oo设计必须具备可复用、可扩充、可维护三个特性。模式是前人历经验证的经验，可以用来解决程序设计当中的各种问题。