# 策略模式 (strategy pattern)

# 鸭子问题

编写鸭子项目，具体要求如下：

有各种鸭子 (比如野鸭，北京鸭，玩具鸭有各种行为，比如叫，飞行等)
显示鸭子的信息

# 首先看使用传统的方式来解决问题

分析和代码实现

写一个父类 Duck 可以为抽象类，也可以为非抽象类。然后下面有各种具体的鸭子它们都是鸭子但分别有不同的行为

这种方式是可以解决问题，但是也存在一些问题

代码实现：

Duck

	public abstract class Duck
	{
	public Duck()
	{}
	// 显示鸭子的信息
	abstract void diplay();
	public void quack()
	{
	System.out.println("鸭子嘎嘎叫~~~");
	}
	public void swim()
	{
	System.out.println("鸭子会游泳~~~");
	}
	public void fly()
	{
	System.out.println("鸭子会飞翔~~~");
	}
	}

PekingDuck

	public class PekingDuck extends Duck
	{
	@Override
	void diplay()
	{
	System.out.println("~~~北京鸭~~~");
	}
	// 因为北京鸭不能飞翔，因此需要重写父类方法
	@Override
	public void fly()
	{
	System.out.println("北京鸭不能飞翔~~~");
	}
	}

ToyDuck

	public class ToyDuck extends Duck
	{
	@Override
	void diplay()
	{
	System.out.println("~~~玩具鸭~~~");
	}
	@Override
	public void quack()
	{
	System.out.println("玩具鸭不能叫~~~");
	}
	@Override
	public void swim()
	{
	System.out.println("玩具鸭不能游泳~~~");
	}
	@Override
	public void fly()
	{
	System.out.println("玩具鸭不能飞翔~~~");
	}
	}

WildDuck

	public class WildDuck extends Duck
	{
	@Override
	void diplay()
	{
	System.out.println("~~~野鸭~~~");
	}
	// 野鸭子会叫，会游泳，会飞翔
	}

Test

	public class Test
	{
	public static void main(String[] args)
	{
	Duck pekingDuck = new PekingDuck();
	pekingDuck.diplay();
	pekingDuck.fly();
	pekingDuck.quack();
	pekingDuck.swim();

	Duck toyDuck = new ToyDuck();
	toyDuck.diplay();
	toyDuck.fly();
	toyDuck.quack();
	toyDuck.swim();

	Duck wildDuck = new WildDuck();
	wildDuck.diplay();
	wildDuck.fly();
	wildDuck.quack();
	wildDuck.swim();
	}
	}

打印结果：

	~~~北京鸭~~~
	北京鸭不能飞翔~~~
	鸭子嘎嘎叫~~~
	鸭子会游泳~~~
	~~~玩具鸭~~~
	玩具鸭不能飞翔~~~
	玩具鸭不能叫~~~
	玩具鸭不能游泳~~~
	~~~野鸭~~~
	鸭子会飞翔~~~
	鸭子嘎嘎叫~~~
	鸭子会游泳~~~

传统的方式实现的问题分析和解决方案：

其它鸭子，都继承了 Duck 类，所以 fly 让所有子类都会飞了，这是不正确的。
上面说 1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其它部分。会有溢出效应
为了改进 1 问题，我们可以通过覆盖 fly 方法来解决 ⇒ 覆盖解决
问题又来了，如果我们有一个玩具鸭子 ToyDuck，这样就需要 ToyDuck 去覆盖 Duck 的所有实现的方法这样很不方便所以 ⇒ 解决思路：策略模式 (strategy pattern)

# 策略模式基本介绍

策略模式 (Strategy Pattern) 中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
这算法体现了几个设计原则，第一：把变化的代码从不变的代码中分离出来；第二：针对接口编程而不是具体类 (定义了策略接口)；第三：多用组合 / 聚合，少用继承 (客户通过组合 / 聚合方式使用策略)

策略模式的原理类图

Context 中有什么方法，我就可以去选用下面某一个具体实现

说明：从上图可以看到，客户 context 有成员变量 strategy 或者其它的策略接口，至于需要使用到哪个策略，我们可以在构造器中指定

# 策略模式解决鸭子问题

应用实例需求

编写程序完成前面的鸭子项目，要求使用策略模式

思路分析

策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为的变化独立于算法的使用者

                            **思路图**

代码实现

FlyBehavior 策略接口

	public interface FlyBehavior
	{
	// 子类具体实现
	void fly();
	}

策略接口下的实现类

NoFlyBehavior

	public class NoFlyBehavior implements FlyBehavior
	{
	@Override
	public void fly()
	{
	System.out.println("不会飞翔技术");
	}
	}

BeadFlyBehavior

	public class BeadFlyBehavior implements FlyBehavior
	{
	@Override
	public void fly()
	{
	System.out.println("飞翔技术不行");
	}
	}

GoodFlyBehavior

	public class GoodFlyBehavior implements FlyBehavior
	{
	@Override
	public void fly()
	{
	System.out.println("飞翔技术高超");
	}
	}

Duck 不同鸭子的抽象类

	public abstract class Duck
	{
	// 属性，策略接口
	FlyBehavior flyBehavior;

	abstract void display();

	public void quack()
	{
	System.out.println("鸭子嘎嘎叫");
	}

	public void swim()
	{
	System.out.println("鸭子会游泳");
	}

	public void fly()
	{
	if(flyBehavior != null)
	{
	flyBehavior.fly();
	}
	}

	// 如果我们希望在运行过程中去改变 fly 动作，我们还可以提供一个 set 方法
	public void setFlyBehavior(FlyBehavior flyBehavior)
	{
	this.flyBehavior = flyBehavior;
	}
	}

PekingDuck

	public class PekingDuck extends Duck
	{
	public PekingDuck()
	{
	// 假如北京鸭可以飞翔，但是飞翔技术一般
	// flyBehavior = new NoFlyBehavior();
	// 我们可以使用接口去控制
	flyBehavior = new BeadFlyBehavior();
	}

	@Override
	public void display()
	{
	System.out.println("~~~这是一只北京鸭~~~");
	}
	}

ToyDuck

	public class ToyDuck extends Duck
	{
	public ToyDuck()
	{
	flyBehavior = new NoFlyBehavior();
	}

	@Override
	public void display()
	{
	System.out.println("~~~这是一只玩具鸭~~~");
	}
	}

WildDuck

	public class WildDuck extends Duck
	{
	public WildDuck()
	{
	// 野鸭的飞翔技术非常好
	flyBehavior = new GoodFlyBehavior();
	}

	@Override
	public void display()
	{
	System.out.println("~~~这是一只野鸭~~~");
	}
	}

Test 测试代码

	public class Test
	{
	public static void main(String[] args)
	{
	WildDuck wildDuck = new WildDuck();
	wildDuck.display();
	wildDuck.fly();
	ToyDuck toyDuck = new ToyDuck();
	toyDuck.display();
	toyDuck.fly();
	PekingDuck pekingDuck = new PekingDuck();
	pekingDuck.display();
	// 假如我们说，北京鸭确实飞不起来可以通过 setfly 的函数设置
	pekingDuck.setFlyBehavior(new NoFlyBehavior());
	pekingDuck.fly();
	}
	}

打印结果：

	~~~这是一只野鸭~~~
	飞翔技术高超
	~~~这是一只玩具鸭~~~
	不会飞翔技术
	~~~这是一只北京鸭~~~
	不会飞翔技术

# 策略模式在 JDK-Arrays 应用的源码分析

策略模式在 JDK-Arrays 应用源码分析

JDK 的 Arrays 的 Comparator 就使用了策略模式
代码分析 + Debug 源码 + 模式角色分析

	@SuppressWarnings("all")
	public class Strategy
	{
	public static void main(String[] args)
	{
	Integer data[] = {9, 1, 2, 8, 4, 3};
	// 实现升序排序，返回 - 1 放左边，1 放右边，0 保持不变
	// 说明
	// 1. 实现了 Comparator 接口 (策略接口) ，匿名类对象 new Comparator<Integer>(){...}
	// 2. 对象 new Comparator<Integer>(){...} 就是实现了策略接口的对象
	// 3. public int compare (Integer o1, Integer o2){} 指定具体的处理方式
	Comparator<Integer> comparator = new Comparator<Integer>()
	{
	@Override
	public int compare(Integer o1, Integer o2)
	{
	if (o1 > o2)
	{
	return 1;
	}
	else
	{
	return -1;
	}
	}
	};
	// 说明 sort
	/**
	* public static <T> void sort (T [] a, Comparator<? super T> c)
	* {
	* if (c == null)
	* {
	* // 如果 c 为空就使用默认方式来处理
	* sort (a);
	* } else
	* {
	* if (LegacyMergeSort.userRequested)
	* // 使用策略对象 c
	* legacyMergeSort (a, c);
	* else
	* // 使用策略对象 c
	* TimSort.sort (a, 0, a.length, c, null, 0, 0);
	* }
	* }
	*/
	Arrays.sort(data, comparator);
	System.out.println(Arrays.toString(data));
	Integer data1[] = {9, 1, 2, 8, 4, 3};
	// 方式 2 - 使用 lambda 表达式实现策略模式
	Arrays.sort(data1, (var1, var2) -> {
	if(var1.compareTo(var2) < 0)
	{
	return 1;
	}else
	{
	return -1;
	}
	});
	System.out.println(Arrays.toString(data1));
	}
	}

# 策略模式的注意事项和细节

策略模式的关键是：分析项目中变化部分与不变部分
策略模式的核心思想是：多用组合 / 聚合少用继承：用行为类组合，而不是行为的继承。更有弹性
体现了 “对修改关闭，对扩展开放” 原则，客户端增加行为不用修改原有代码，只要添加一种策略 (或者行为) 即可，避免了多重转移语句 (if else if else)
提供了可以替换继承关系的办法：策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换，易于理解，易于扩展
需要注意的是：每添加一个策略就要增加一个类，当策略过多时会导致类数目庞大

计算机学科设计模式

# 策略模式 **(strategy pattern)**