Java设计模式——策略模式

   《Thinking in Java》看了一大部分，发现其中好多地方讲到了设计模式。自己都没有仔细研究过设计模式，所以有些地方还是看不懂。于是开始了另一本大部头的书《Head First 设计模式》。今天看了第一章，以一种非常轻松，循序渐进的方式将设计模式，很喜欢这本书。大部分内容和实例都摘抄自课本。

1、首先，我们在学习设计模式之前，需要对OO（面向对象编程）有一定的了解。主要为抽象、封装、多态和继承等概念。如果这些不了解，就没法学习设计模式。设计模式就我自己理解是一种思想，是在需求分析之后，架构设计和写代码之前考虑的事情。
2、策略模式：该书的第一章以Duck类及一系列的行为为例，说明了策略模式的思想。
首先我们会有鸭子类，鸭子有两种主要行为：飞行和鸣叫。但是对于不同类型的鸭子，飞行和鸣叫的方式都是不同的。因此，我们将鸭子类和鸭子的行为独立开来，设计一族算法，将不同的行为封装起来，同时让他们之间可以互相替代。这就是设计模式的主要思想。

其中用到了继承、接口的实现、组合。

3、下面我们以具体的例子说明策略模式。





鸭子会将飞行和呱呱叫的动作委托给别人处理，而不是在Duck类内部处理。


Duck类：

public class Duck {

	//这里用到了组合，每个鸭子都有飞行和鸣叫的行为，是一种has-a的关系
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;

	public Duck(){
		
	}

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

该类其实是作为策略模式的客户端，会调用算法族中行为。

FlyBehavior接口

public interface FlyBehavior {
	//飞行行为
	public void fly();
}

QuackBehavior接口

public interface QuackBehavior {
	//叫声行为
    public void quack();
}

这个角色是所有的策略算法所需要的接口。


具体的算法族:
对于飞行行为有以下两个算法

public class FlyNoWay implements FlyBehavior{
	@Override
	public void fly() {

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

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

}

对于鸣叫，有以下三个算法

public class Quack implements QuackBehavior{
	@Override
	public void quack() {

		System.out.println("Quack");
	}
}

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

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

对于一系列具体的策略算法，大家的地位是完全一样的，正因为这个平等性，才能实现算法之间可以相互替换。所有的策略算法在实现上也是相互独立的，相互之间是没有依赖的。
所以可以这样描述这一系列策略算法：策略算法是相同行为的不同实现。

测试程序：

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

测试结果：
I'm flying!!
Quack

4、可以通过setter方法在运行过程中动态的设定行为，在Duck类中添加如下方法：

/**
	 * 功能:动态添加飞行行为<br>
	 * @param flyBehavior the flyBehavior to set
	 */
	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}
	/**
	 * 功能:动态添加鸣叫行为<br>
	 * @param quackBehavior the quackBehavior to set
	 */
	public void setQuackBehavior(QuackBehavior quackBehavior) {
		this.quackBehavior = quackBehavior;
	}

制造新的鸭子类型，模型鸭（ModelDuck）

public class ModelDuck extends Duck{
	public ModelDuck (){
		flyBehavior=new FlyNoWay();
		quackBehavior=new Quack();
	}

	public void display(){
		System.out.println("I'm a model duck");
	}
}

在飞行算法族中添加新的算法，即新的飞行方式：

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

测试类中添加如下代码：

                    

Duck model=new ModelDuck();
		model.performFly();
		model.setFlyBehavior(new FlyRocketPowered());
		model.performFly();

可以看到测试结果如下：

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

从以上的例子中，我们发现：策略模式在每一个时刻只能使用一个具体的策略实现对象，虽然可以动态地在不同的策略实现中切换，但是同时只能使用一个。

5、策略模式的优缺点

策略模式的优点
　　（1）策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面，从而避免代码重复。

　　（2）使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重条件语句里面，比使用继承的办法还要原始和落后。

策略模式的缺点
　　（1）客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道算法或行为的情况。

　　（2）由于策略模式把每个具体的策略实现都单独封装成为类，如果备选的策略很多的话，那么对象的数目就会很可观。

6、在这一章中学到的设计原则：
(1)把应用中需要变化的地方独立出来，不要和不需要变化的代码混在一起
(2)针对接口编程，而不是针对实现编程
(3)多用组合，少用继承