策略模式
策略模式将可变的部分从程序中抽象分离成算法接口，在该接口下分别封装一系列算法实现，
并使得他们可以相互替换，从而导致客户端程序独立于算法的改变。
实例：
假如有一个鸭子类：鸭子有叫的功能，有展示功能，另外需要给鸭子加一个飞行能力，让鸭子飞起来，但是对于不同的鸭子有不同的飞行能力，
比如有的展翅高飞，有的不会飞，有的飞向太空。
方案一：继承：
在父类中提供实现方法，子类通过继承获得父类中的飞行行为。
优点：简单易用，已有应用可以快速添加飞行能力。
缺点：不具有灵活性，对未来变更支持性差。假如子类鸭子有跟父类不一样的飞行方法，需要在子类中复写飞行的方法以提供新的
飞行行为，这很容易出差造成错误（粗心的程序员忘记复写），假如一只大黄鸭，是不具备飞行能力的，但是因为程序员忘记复写飞行，导致该大黄鸭能飞。
方案二：抽象方法
在父类中提供抽象方法，强迫子类实现自己的飞行行为。
优点：足够灵活，小伙伴再也不会忘记复写代码了，大黄鸭也不会飞到天上吓你了。
缺点：累死小伙伴，每个子类都要实现一遍代码，即使是相同的行为也不例外。
代码重复，却没有复用代码。万一再有一个bug，哎妈呀，不敢想。
继承是重用代码的利器，但是继承并不总是最好的工具。
解决思想：复合优先于继承，多用组合，少用继承。
组合：在类中增加一个私有域，引用另一个已有的类的实例，通过调用引用实例的方法从而获得新的功能，
这种设计被称为组合（复用）。
就像赛车通过换轮胎，获得超凡奔跑能力。
方案三：组合
将飞行行为抽象为接口，在父类中持有该接口，并由该接口代理飞行行为。
public interface FlyingStragety { void performFly(); }
父类：
private FlyingStragety flyingStragety; public void fly() { flyingStragety.performFly(); }
优点：足够灵活，复用代码，更易于维护。
策略模式的设计原则：
1，找出应用中需要变化的部分，把他们独立出来，不要和那些不需要的代码混在一起（可复用的功能独立出来，供不同的子类重用，这也是为什么不采用抽象的原因）。
2，面向接口编程，而不是面向实现编程。
3，多用组合，少用继承。
策略模式的实现：
1，通过分离变化得出的策略接口Stratege。（策略接口，实现鸭子的飞行行为）。
2，继承策略模式接口，实现Stratege的实现类（不同的飞行行为，分别实现实现类）。
3，策略模式的实现：客户程序有一个"Stratege接口对象"。（在父类抽象类中实现即可）
4，在客户程序中选择/组装正确的Stratege实现。（在stratege对象的set方法里面，传入要选择的具体策略类实例）。
具体代码：
1，先定义一个飞行策略接口，该接口提供一个飞行方法。
package com.Stratege; /* * 策略接口，实现鸭子的飞行行为 * */ public interface FlyingStragety { void performFly(); }
2，对于飞行接口，分别提供几种飞行实现类，来供客户程序选择使用哪个策略Stratege实现。
如：不会飞实现类：
package com.Stratege.impl; import com.Stratege.FlyingStragety; //不能飞行 public class FlyNoWay implements FlyingStragety { @Override public void performFly() { System.out.println("我不会飞行，有点羞涩"); } }
展翅高飞实现类：
package com.Stratege.impl; import com.Stratege.FlyingStragety; //第一种飞行策略：展翅高飞 public class FlyWithMe implements FlyingStragety { @Override public void performFly() { System.out.println("振翅高飞"); } }
3，不同的飞行策略的接口和实现类已经实现了。
现在开始实现客户端类，假如有三种鸟：绿头鸭，红头鸭，橡胶鸭，小黄鸭。其中绿头鸟和红头鸭会飞，
橡胶鸭和小黄鸭不会飞，橡皮鸭子叫声有点沙哑：嘎~嘎~嘎~。
4，定义一个会叫，能展示的鸭子，不同的鸭子展示方式不一样，这里通过一个抽象方法实现，并且采用策略模式提供飞行功能。
策略模式飞行：1，提供策略模式飞行接口对象，2，提供该接口对象的set方法。
3，提供飞行方法，方法里面由策略模式接口对象调用自身的performFly。这样实现了，不同的子类，调用飞行方法，不需要修改飞行方法，
只需要为给策略模式飞行接口对象实例化不同的策略模式实现类。
package com.Stratege; /* * 超类，所有的鸭子都要继承此类 * 抽象了鸭子的行为：显示和叫 * */ public abstract class Duck { //鸭子发出叫声 //通用行为，由超类实现 public void quack() { System.out.println("嘎嘎嘎"); } //显示鸭子的外观，鸭子外观各不相同，声明为abstract，由子类实现 public abstract void display(); private FlyingStragety flyingStragety; public void setFlyingStragety(FlyingStragety flyingStragety) { this.flyingStragety = flyingStragety; } //调用策略接口实现飞行 public void fly() { this.flyingStragety.performFly(); } }
5，不同的鸭子子类分别实例化：在构造方法里面，调用父类的setStragety方法，方法的参数传递对应的实现子类实例，从而实现往子类中注入不同的策略实例，
绿鸭：
package com.Stratege; import com.Stratege.impl.FlyWithMe; public class MallardDuck extends Duck { public MallardDuck() { super(); //给红头鸭提供了一个翅膀飞行的能力 super.setFlyingStragety(new FlyWithMe()); } @Override public void display() { System.out.println("我的头是绿色的"); } }
红头鸭：
package com.Stratege; import com.Stratege.impl.FlyWithMe; public class RedheadDuck extends Duck { public RedheadDuck() { super(); //给红头鸭提供了一个翅膀飞行的能力 super.setFlyingStragety(new FlyWithMe()); } @Override public void display() { System.out.println("我的头是红色的"); } }
橡胶鸭：因为叫声不一样，重写了叫声方法。
package com.Stratege; import com.Stratege.impl.FlyNoWay; public class RubberDuck extends Duck{ public RubberDuck() { super(); //给红头鸭提供了一个翅膀飞行的能力 super.setFlyingStragety(new FlyNoWay()); } @Override public void display() { System.out.println("我全身发黄，嘴巴很红"); } public void quack() { System.out.println("嘎~嘎~嘎~"); } }
大黄鸭：不会飞。
package com.Stratege; import com.Stratege.impl.FlyNoWay; public class BigYellow extends Duck { public BigYellow() { super(); //给红头鸭提供了一个翅膀飞行的能力 super.setFlyingStragety(new FlyNoWay()); } @Override public void display() { System.out.println("我身体很大，全身黄黄"); } }
测试：
package com.Stratege; public class DuckTest { public static void main(String[] args) { System.out.println("测试鸭子程序"); System.out.println("-----------------"); Duck duck=new MallardDuck(); duck.display(); duck.quack(); duck.fly(); System.out.println("-----------------"); Duck duck2=new RedheadDuck(); duck2.display(); duck2.quack(); duck2.fly(); System.out.println("-----------------"); Duck duck3=new RubberDuck(); duck3.display(); duck3.quack(); duck3.fly(); System.out.println("-----------------"); Duck duck4=new BigYellow(); duck4.display(); duck4.quack(); duck4.fly(); } }
运行结果：
测试鸭子程序 ----------------- 我的头是绿色的 嘎嘎嘎 振翅高飞 ----------------- 我的头是红色的 嘎嘎嘎 振翅高飞 ----------------- 我全身发黄，嘴巴很红 嘎~嘎~嘎~ 我不会飞行，有点羞涩 ----------------- 我身体很大，全身黄黄 嘎嘎嘎 我不会飞行，有点羞涩
总结：
策略模式的优点：
1，使用了组合模式，使得架构更加灵活。
2，富有弹性，可以较好的应对变化（开-闭原则）。
3，更好的代码复用性。（相对于继承。而且如果相同的策略，只需要实例化对应的策略模式类就行了）
4，消除大量的条件语句。（不同的子类，当对于不同的策略，只需要为策略接口对象，实例化对应的策略模式类就行了）
适用场景：
1，许多相关的类，仅仅是行为差异。
2，运行时选取不同的算法变体。
3，通过条件语句在多个分支中选取一。