《Head First 设计模式》（一）：策略模式

1. 范例

公司做了一套鸭子模拟游戏（SimUDuck），游戏中会有各种鸭子，会游戏划水、会呱呱叫。

2. 初始化版本—继承

定义一个鸭子父类：Duck，并让各种鸭子继承此父类

鸭子父类：Duck类方法分析：

所有鸭子都会呱呱叫，所以此行为由父类实现
所有鸭子都会游泳，所以此行为由父类实现
因为每一个鸭子的外观都不尽相同，所以此外观方法定义为抽象方法，具体内容由子类实现

鸭子父类：Duck类

package com.jbp.designpattern;/*** @ClassName: Duck* @description: 鸭子父类* @author: JiangBeiPing* @create: 2021-06-22 14:57* @Version: 1.0**/
public abstract class Duck {// 呱呱叫行为方法实现public void quack(){System.out.println("呱呱叫...");}// 游泳行为方法实现public void swim(){System.out.println("游泳...");}// 外观：每个鸭子的外观都不相同，由子类自己实现public abstract void display();}

鸭子子类：绿头鸭

package com.jbp.designpattern;/*** @ClassName: MallardDuck* @description: 绿头鸭子类* @author: JiangBeiPing* @create: 2021-06-22 16:59* @Version: 1.0**/
public class MallardDuck extends Duck {@Overridepublic void display() {System.out.println("绿头鸭...");}
}

鸭子子类：红头鸭

package com.jbp.designpattern;/*** @ClassName: RedheadDuck* @description: 红头鸭子类* @author: JiangBeiPing* @create: 2021-06-22 17:00* @Version: 1.0**/
public class RedheadDuck extends Duck{@Overridepublic void display() {System.out.println("红头鸭...");}
}

2.1 需求变化—新增会飞的鸭子

后续公司决定在此模拟程序新增会飞的鸭子

功能实现思路：在Duck类中加上飞行fly（）方法

Duck类：

package com.jbp.designpattern;/*** @ClassName: Duck* @description: 鸭子父类* @author: JiangBeiPing* @create: 2021-06-22 14:57* @Version: 1.0**/
public abstract class Duck {// 呱呱叫行为方法实现public void quack(){System.out.println("呱呱叫...");}// 游泳行为方法实现public void swim(){System.out.println("游泳...");}// 外观：每个鸭子的外观都不相同，由子类自己实现public abstract void display();// 新增飞行方法public void fly(){System.out.println("飞行...");}}

鸭子子类：橡皮鸭

package com.jbp.designpattern;/*** @ClassName: RubberDuck* @description: 橡皮鸭子类* @author: JiangBeiPing* @create: 2021-06-22 17:13* @Version: 1.0**/
public class RubberDuck extends Duck{// 橡皮鸭只能吱吱吱叫，所以覆盖此方法@Overridepublic void quack() {System.out.println("吱吱吱");}@Overridepublic void display() {System.out.println("橡皮鸭...");}
}

带来的问题：游戏中，所有的鸭子都会飞（橡皮、玩具鸭也都会飞）

解决方案：

把橡皮鸭子类的飞行方法fly（）覆盖成空方法。

新的问题—后面的每创建一个新的鸭子类，都需要按情况进行方法覆盖。

package com.jbp.designpattern;/*** @ClassName: RubberDuck* @description: 橡皮鸭子类* @author: JiangBeiPing* @create: 2021-06-22 17:13* @Version: 1.0**/
public class RubberDuck extends Duck{// 橡皮鸭只能吱吱吱叫，所以覆盖此方法@Overridepublic void quack() {System.out.println("吱吱吱");}@Overridepublic void display() {System.out.println("橡皮鸭...");}@Overridepublic void fly() {}
}

3. 优化版本—接口

把 fly（）方法从父类 Duck类中抽取成一个 Flyable接口，只需要会飞的鸭子子类实现该接口即可，不需要飞行的鸭子子类无需理会此接口。同理，把呱呱呱叫的方法 quack() 也抽取成一个 Quackable接口。

新的问题：

代码复用性差。

比如，有 n 个鸭子子类，就需要实现 n 次飞行或者叫声的方法的具体内容。

4. 最终版本—策略模式

设计原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码耦合在一起。

思路分析：

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

变化的部分：

quack()：鸭子叫声
fly()：飞行

不会变化的部分：

swim()：游泳

新增两个类，一个是 fly()飞行相关的，一个是quack()鸭子叫声相关的，每一个类实现各自的动作。

鸭子行为设计思路分析：

如何设计实现飞行和鸭子叫行为的类？

应该在鸭子类中包含设定行为的方法，这样就可以在“运行时”动态地改变该子类的行为。比如，在产生新的绿头鸭实例时，再指定特定的的“类型”的飞行行为给它。

设计原则：针对接口编程，而不是针对实现编程。

利用接口代表行为，比如，FlyBehavior 和 QuackBehavior，而行为的实现类自行实现自己对应的接口。

所以，鸭子子类不会去实现 Flying 和 Quacking 接口。而是由特定的行为类专门实现 FlyBehavior 和 QuackBehavior。

之前的做法是：行为来自鸭子父类Duck类，或者继承某个行为接口，由鸭子子类自行实现。这两种方法都是行为依赖于实现。

现在的做法是：鸭子的子类使用接口 FlyBehavior 和 QuackBehavior所表示行为，所以具体的实现由行为实现类具体实现而不是由鸭子子类实现。

代码实现：

飞行接口：

package com.jbp.designpattern;/*** @ClassName: FlyBehavior* @description: 飞行接口:所有的飞行鸭子类都需实现此接口，并且实现fly()* @author: JiangBeiPing* @create: 2021-06-22 18:06* @Version: 1.0**/
public interface FlyBehavior {public void fly();
}

飞行实现类：

package com.jbp.designpattern;/*** @ClassName: FlyWithWings* @description: 飞行行为具体实现类* @author: JiangBeiPing* @create: 2021-06-22 18:08* @Version: 1.0**/
public class FlyWithWings implements FlyBehavior {@Overridepublic void fly() {System.out.println("飞行...");}
}

飞行实现类：

package com.jbp.designpattern;/*** @ClassName: FlyNoWay* @description: 不会飞行的行为具体实现类* @author: JiangBeiPing* @create: 2021-06-22 18:10* @Version: 1.0**/
public class FlyNoWay implements FlyBehavior {@Overridepublic void fly() {// 什么都不做，不会飞行}
}

叫声接口：

package com.jbp.designpattern;/*** @ClassName: QuackBehavior* @description: 鸭子叫声实现接口* @author: JiangBeiPing* @create: 2021-06-22 18:14* @Version: 1.0**/
public interface QuackBehavior {public void quack();}

叫声实现类：

package com.jbp.designpattern;/*** @ClassName: Quack* @description: 鸭子呱呱呱叫行为实现* @author: JiangBeiPing* @create: 2021-06-22 18:16* @Version: 1.0**/
public class Quack implements QuackBehavior{@Overridepublic void quack() {System.out.println("呱呱叫...");}
}

叫声实现类：

package com.jbp.designpattern;/*** @ClassName: Squeak* @description: 鸭子吱吱吱叫行为具体实现* @author: JiangBeiPing* @create: 2021-06-22 18:18* @Version: 1.0**/
public class Squeak implements QuackBehavior{@Overridepublic void quack() {System.out.println("吱吱吱...");}
}

叫声实现类：

package com.jbp.designpattern;/*** @ClassName: MuteQuack* @description: 鸭子不能叫行为具体实现* @author: JiangBeiPing* @create: 2021-06-22 18:19* @Version: 1.0**/
public class MuteQuack implements QuackBehavior{@Overridepublic void quack() {// 什么都不做，不会叫}
}

4.1 修改鸭子父类 Duck 类

现在鸭子的飞行和叫声动作会由行为类进行具体实现，而不是在Duck 类或子类中自己实现。

首先，在Duck 类中新增两个实例变量，分别是 FlyBehavior 和 QuackBehavior ，声明为接口类型，而不是具体类实现类型。每个鸭子子类对象都会动地设置这些变量以在运行时引用正确的行为类型。

然后，用两个方法 performFly（）和 performQuack（）替换Duck 类中的 fly（）和quack（）。

Duck 类：

package com.jbp.designpattern;/*** @ClassName: Duck* @description: 鸭子父类* @author: JiangBeiPing* @create: 2021-06-22 14:57* @Version: 1.0**/
public abstract class Duck {// 每个鸭子子类都会引用实现FlyBehavior接口的对象FlyBehavior flyBehavior;QuackBehavior quackBehavior;// 游泳行为方法实现public void swim(){System.out.println("游泳...");}// 外观：每个鸭子的外观都不相同，由子类自己实现public abstract void display();// 鸭子对象不亲自处理叫声行为，而是由quackBehavior引用的对象实现public void performQuack(){quackBehavior.quack();}public void performFly(){flyBehavior.fly();}}

绿头鸭子类：

package com.jbp.designpattern;/*** @ClassName: MallardDuck* @description: 绿头鸭子类* @author: JiangBeiPing* @create: 2021-06-22 16:59* @Version: 1.0**/
public class MallardDuck extends Duck {@Overridepublic void display() {System.out.println("绿头鸭...");}// 当绿头鸭子类实例化时，构造器会把继承来的quackBehavior实例变量初始化成Quack类的新实例public MallardDuck(){// 绿头鸭使用Quack类处理叫声进行呱呱叫quackBehavior = new Quack();flyBehavior = new FlyWithWings();}
}

测试：

4.2 动态设定行为（避免构造器中设定）

在鸭子子类中通过属性设置方法（setter method）来设置鸭子的行为，从而避免在鸭子的构造器内实例化。

Duck 类新增setter方法：

package com.jbp.designpattern;/*** @ClassName: Duck* @description: 鸭子父类* @author: JiangBeiPing* @create: 2021-06-22 14:57* @Version: 1.0**/
public abstract class Duck {// 每个鸭子子类都会引用实现FlyBehavior接口的对象FlyBehavior flyBehavior;QuackBehavior quackBehavior;// 游泳行为方法实现public void swim(){System.out.println("游泳...");}// 外观：每个鸭子的外观都不相同，由子类自己实现public abstract void display();// 鸭子对象不亲自处理叫声行为，而是由quackBehavior引用的对象实现public void performQuack(){quackBehavior.quack();}public void performFly(){flyBehavior.fly();}public void setFlyBehavior(FlyBehavior flyBehavior) {this.flyBehavior = flyBehavior;}public void setQuackBehavior(QuackBehavior quackBehavior) {this.quackBehavior = quackBehavior;}
}

鸭子子类：模型鸭：

package com.jbp.designpattern;/*** @ClassName: ModelDuck* @description: 模型鸭子类* @author: JiangBeiPing* @create: 2021-06-23 11:02* @Version: 1.0**/
public class ModelDuck extends Duck{@Overridepublic void display() {System.out.println("模型鸭...");}public ModelDuck() {// 模型鸭不会飞flyBehavior = new FlyNoWay();quackBehavior = new Quack();}
}

新增新的飞行行为：火箭飞行：

package com.jbp.designpattern;/*** @ClassName: FlyRocketPowered* @description: 火箭动力飞行* @author: JiangBeiPing* @create: 2021-06-23 11:05* @Version: 1.0**/
public class FlyRocketPowered implements FlyBehavior{@Overridepublic void fly() {System.out.println("火箭动力飞行...");}
}

测试：

package com.jbp.designpattern;/*** @ClassName: DuckTest* @description: 鸭子类测试* @author: JiangBeiPing* @create: 2021-06-22 17:16* @Version: 1.0**/
public class DuckTest {public static void main(String[] args) {Duck modelDuck = new ModelDuck();// 第一次调用performFly()，飞行行为由FlyBehavior接口（具体实现由FlyNoWay实现），在模型鸭构造器设置modelDuck.performFly();// 调用父类的setter方法，把火箭飞行行为设置到模型鸭中modelDuck.setFlyBehavior(new FlyRocketPowered());// 模型鸭动态地改变自身的飞行行为modelDuck.performFly();}
}

5. 总结

重构后，类分为：鸭子子类继承Duck、飞行行为实现FlyBehavior接口、呱呱叫行为实现QuackBehavior接口。

描述事情的方式也从“一组行为”改成“一族算法”，算法表示鸭子能做的事情（不同的叫声和不同的飞行方式）。

每一个鸭子都有一个FlyBehavior和QuackBehavior，飞行和叫声行为都由其行为具体实现类实现。当两个类结合起来一起使用，如同测试类中，即是组合（composition）。这种方式和继承的区别是，鸭子子类的行为不是继承而来的，而是和适当的行为对象组合而来。

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

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