【设计模式】HeadFirst设计模式（一）：策略（Strategy）模式

1、概述

在软件开发的过程中，实现一个功能可能会使用很多种算法，一种比较常用的做法是把这些算法或者策略写在一个类中，一个算法写一个方法。当我们需要新增一个算法的时候，我们需要修改封装这些算法的类，并且在客户端也可能需要修改相应的实现。如果一个项目需要很多的算法的情况下，这样的设计会增加项目的维护复杂度。

2、问题

如何让算法独立于使用它的客户而独立变化

3、定义

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

4、设计原则

把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口（也可以是抽象类，java中的abstract），然后在这个类中包含这个接口（虚类）对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。 

5、适用环境

   因为策略模式主要针对一族算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响 到客户端的情况下发生变化。通常，策略模式适用于当一个应用程序需要实现一种特定的服务或者功能，而且该程序有多种实现方式时使用。

6、结构

三个对象：

(1) 环境对象： 持有抽象策略对象的引用，供给客户端直接调用

(2)抽象策略对象：策略类，由接口或者抽象类实现

(3)具体策略对象：包装了相关算法和行为

UML类图：

7、应用场景——模拟鸭子

背景： Joe上班的公司做了一套鸭子游戏，游戏中有各种的鸭子：一边游泳，一边呱呱叫。设计了一个鸭子超类，让各种鸭子继承此超类

Duck抽象类：quack()方法（已经实现），swim()方法（已经实现），display()方法是抽象方法

MallardDuck类：display()方法描述“鸭子是绿头”

RedheadDuck类：display()方法描述“鸭子是红头”

问题一：老板决定开发一种能够飞的鸭子出来，把竞争者抛在后头。需要怎么设计？

这是很简单的事情嘛，只需要在 Duck 超类中增加一个 fly() 方法就可以了。这个时候问题出来了，所有的鸭子都继承了 fly() 方法，导致了橡皮鸭子在天上飞（橡皮鸭子不会飞）

所以，我们要在橡皮鸭子类（RubberDuck）中把 fly() 方法覆盖了，让什么事情都不做，并且把 quack() 方法覆盖了，让“鸭子呱呱叫” 变成 “鸭子吱吱叫”

我们看到新增加了一个类 RubberDuck 橡皮鸭子类：

quack()方法：覆盖成吱吱叫

display()方法：外观是橡皮鸭

fly()方法：覆盖，变成什么事情都不做

问题二：如果，我们要新增加一个 诱饵鸭DecoyDuck 类（不会飞也不会叫）该怎么办？

按照上边继承的做法：把quack()方法覆盖成什么也不做，把fly()方法覆盖成什么也不做，把display()方法实现为：外观为诱饵鸭

问题三：主管说，公司每过6个月要更新一次产品。Joe知道规格会经常改变，每当有新的鸭子子类出现的时候，他就要被迫检查并可能需要覆盖fly()和quack()方法。由此可见，继承并不是答案，Joe需要怎么办呢？

Joe想到了如下的解决方案：

Flyable接口：放一个fly()方法

Quackable接口：放入quack()方法

Duck抽象类（或接口）：放入display()和swim()方法，因为所有鸭子都会这两个方法

MallardDuck类：绿头鸭子，display()表现为绿头，fly()表现为会飞，quack()表现为呱呱叫

RedheadDuck类：红头鸭子，display()表现为红头，fly()表现为会飞，quack()表现为呱呱叫

RubberDuck类：橡皮鸭子，display()表现为橡皮鸭，quack()表现为 吱吱叫 （因为不会飞所以没有实现Flyable接口）

DecoyDuck类：诱饵鸭， display()表现为诱饵鸭 （因为不会飞不会叫所以不实现两个接口）

问题三：这个主意真的太笨了，如果这样设计的话重复的代码会变多。如果48个Duck的子类都要稍微修改一下飞行的行为，那么在48只鸭子类中的fly()方法都要实现

设计原则：把应用中可能需要变化的地方独立出来，不要和不需要变化的代码混合在一起（如果每次有新的需求，都会使某方面代码发生变化，那么久可以确定这部分代码需要被抽取出来）

接下来，我们就要设计鸭子了

(1) 分开变化的和不会变化的部分

变化的部分：鸭子的飞行行为和叫的行为

不变的部分：鸭子的描述

所以，我们可以得到下边的UML图：

下边我们看一下具体的实现：

FlyBehavior接口

public interface FlyBehavior {
	void fly();
}

public class FlyWithWings implements FlyBehavior {
	public void fly() {
		System.out.println("I&＃39;m flying!");
	}
}

public class FlyNoWay implements FlyBehavior{
	public void fly(){
		System.out.println("I can&＃39;t fly.");
	}
}

public interface QuackBehavior {
	void quack();
}

public class Quack implements QuackBehavior{
	public void quack(){
		System.out.println("quack");
	}
}

public class Squeak implements QuackBehavior{
	public void quack(){
		System.out.println("Squeak");
	}
}

public class MuteQuack implements QuackBehavior{
	public void quack(){
		System.out.println("<>");
	}
}

public abstract class Duck {
	protected FlyBehavior flyBehavior;
	protected QuackBehavior quackBehavior;
	
	public abstract void display();
	
	public void performFly(){
		flyBehavior.fly();
	}

	public void performQuack(){
		quackBehavior.quack();
	}
	
	public void swim(){
		System.out.println("All ducks float, even decoys!");
	}

	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}

	public void setQuackBehavior(QuackBehavior quackBehavior) {
		this.quackBehavior = quackBehavior;
	}
}

public class DecoyDuck extends Duck {
	//构造方法，初始化确定诱饵鸭不会飞不会叫
	public DecoyDuck() {
		flyBehavior = new FlyNoWay();
		quackBehavior = new MuteQuack();
	}
	//描述方法，得自Duck类
	public void display() {
		System.out.println("I&＃39;m a decoy duck.");
	}
	//改变鸭子行为：会飞会叫
	public void changeBehavior() {
		setFlyBehavior(new FlyWithWings());
		setQuackBehavior(new Quack());
	}
}

【设计模式】HeadFirst设计模式（一）：策略（Strategy）模式