Head First 设计模式（1）——策略模式

设计实现一个鸭子模拟器，要让鸭子实现不同的飞行动作和不同的鸭叫声或者不同的颜色，我们该怎么做呢？

1、如果用继承来实现，那么我们的代码将会变得非常的复杂，而且代码的后期维护将会变得很困难（我想再加个新的特征怎么办？又要把所有的对象都实现一遍？）
2、如果用接口来实现，因为接口无法实现方法，我们必须在所有的子类中一个一个的实现他们，这将导致代码大量的重复，这简直不能忍。

设计原则1：封装变化

把应用中的可能需要变化的地方单独拿出来，与那些不会变化的代码独立开来。
把需要变化的代码封装起来，这样就可以轻易改变他们，而不会影响其他不会变化的代码。
这样的代码的耦合性就大大的降低了，这也是面向对象设计的核心之一。

设计原则2：面向接口编程，而不是面向实现编程

我们这里可以把鸭子的飞行动作、叫声和颜色分为三组类（注意是组，不是个）
每一组类都写一个接口，其中有一个对应的方法，然后这组类中的所有类都实现这个接口。类似下面这样：

接口 FlyBehavior ：

public interface FlyBehavior {
	public void fly();
}

实现FlyBehavior 的类：

①实现了所有有翅膀的鸭子的飞行动作

public class FlyWithWings implements FlyBehavior{
	@Override
	public void fly(){
		System.out.println("I'm flying");
	}
}

②实现了所有不会飞的鸭子的动作

public class FlyNoWay implements FlyBehavior{

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

接口QuackBehavior：

public interface QuackBehavior {

	public void quack();
}

实现QuackBehavior的类

①真的呱呱叫

public class Quack implements QuackBehavior{

	public void quack(){
		System.out.println("I'm quack");
	}
}

②名为呱呱叫，其实什么也不做

public class MuteQuack implements QuackBehavior{

	public void quack(){
		System.out.println("<< Silence >>");
	}
}

③名为呱呱叫，其实是吱吱叫

public class Squeak implements QuackBehavior{

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

通过以上代码可以发现，实现接口的类中实现的方法都是一个具体的方法，比如鸭子的飞行动作就分别通过两个类来实现的，这样就可以动态的改变鸭子的行为了，而不会影响到其他的代码。

设计原则3：多用组合，少用继承

现在通过组合的方式来整合鸭子的行为

先写一个Duck类，也就是鸭子的父类。

public class Duck {

	//实例变量，鸭子通过调用他们的实现类来控制鸭子的行为
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;
	
	public Duck(){
		
	}
	
	public void swim(){
		System.out.println("All ducks can swim");
	}
	
	/**
	 * 通过引用对象调用鸭子飞行动作的方法
	 */
	public void performFly(){
		flyBehavior.fly();
	}
	
	/**
	 * 通过引用对象调用鸭子叫的方法
	 */
	public void performQuack(){
		quackBehavior.quack();
	}
}

再来实现一个具体的鸭子，也就是Duck的子类

public class MallarDuck extends Duck{

	public MallarDuck(){
		/**
		 * 给父类中已经定义的对象赋一个实例
		 * 选择一个需要实现的行为对应的实现类
		 */
		flyBehavior = new FlyWithWings();
		quackBehavior = new Quack();
	}
}

最后加一个主类来测试我们写的代码：

public class MainTest {

	public static void main(String[] args){
		Duck mallarDuck = new MallarDuck();
		mallarDuck.performFly();
		mallarDuck.performQuack();
	}
}

测试结果：

这里我们已经低耦合地实现了一个会飞会叫的鸭子。但是我们能不能动态的改变鸭子的行为呢？比如我想让不会叫的鸭子变得会叫。

答案是可以的。我们在Duck类中再增加两个方法来动态改变鸭子控制行为的接口对象。

public void setFly(FlyBehavior fb){
		this.flyBehavior = fb;
	}
	
public void setQuack(QuackBehavior qb){
		this.quackBehavior = qb;
	}

改变一下具体的鸭子类：

public class MallarDuck extends Duck{

	public MallarDuck(){
		/**
		 * 给父类中已经定义的对象赋一个实例
		 * 选择一个需要实现的行为对应的实现类
		 */
		flyBehavior = new FlyWithWings();
		quackBehavior = new MuteQuack(); //鸭子不会叫
	}
}

再来测试一下代码：

public class MainTest {

	public static void main(String[] args){
		Duck mallarDuck = new MallarDuck();
		mallarDuck.performFly();
		mallarDuck.performQuack();
		//通过动态改变接口对象，来动态改变鸭子的行为
		mallarDuck.setQuack(new Quack());
		mallarDuck.performQuack();
	}
}

测试结果：

看到没，鸭子从不会叫，动态的改变成了一个会叫的鸭子。

这就是设计模式之一的策略模式，可以提供很多种算法给客户使用，而客户不需要关心它的内部实现。

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