原则：将经常改变的和不经常改变的分离设计 ，面向接口而非面向实现编程，多组合，少继承
举个例子 现在有电影院，一年四季根据季节去打折，假设有一个movie类，那么正常设计里面会有一个打折方法，方法内部实现是根据季节不同去返回不同的折后价格，如果需求改变，则该方法需要重新编写代码，然后测试前面的代码是否会受到影响。
策略模式 ，依然是有继承的，只不过是将行为 单独拿出来，以面向接口的形式，根据不同的行为分别去实现
这里，行为接口是：策略标识，而行为接口的具体实现类是：具体策略
再配合组合的形式，就可以动态的对不同子类的不同行为进行赋值
=============================华丽分割==================================
抽象类
public abstract class Movie { private double price=100; public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } private Rebate rebate;//这里是用了组合的形式 将行为接口作为属性，并提供set方法在运行时动态传入 public void setRebate(Rebate rebate) { this.rebate = rebate; } public void rebateing(double price ){ this.rebate.rebate(price); } }子类1
public class SpringMovie extends Movie { }子类2
public class SummerMovie extends Movie { }子类3
public class AutumnMovie extends Movie { }折扣行为接口
public interface Rebate { public void rebate(double price); }接口实现1
public class SpringRebate implements Rebate { @Override public void rebate(double price ) { System.out.println("春季打折后："+price*0.5); } }接口实现2
public class SummberRebate implements Rebate { @Override public void rebate(double price ) { System.out.println("夏季打折后："+price*0.2); } }接口实现3
public class AutumnRebate implements Rebate { @Override public void rebate(double price ) { System.out.println("秋季打折后："+price*0.8); } }测试类
public class Test { public static void main(String[] args) { System.out.println("春天到了"); Movie movie1=new SpringMovie(); movie1.setRebate(new SpringRebate()); movie1.rebateing(movie1.getPrice()); System.out.println("夏天到了"); Movie movie2=new SpringMovie(); movie1.setRebate(new SummberRebate()); movie1.rebateing(movie2.getPrice()); System.out.println("秋天到了"); Movie movie3=new SpringMovie(); movie1.setRebate(new AutumnRebate()); movie1.rebateing(movie3.getPrice()); } }输出内容
春天到了 春季打折后：50.0 夏天到了 夏季打折后：20.0 秋天到了 秋季打折后：80.0
无论是哪一个季节折扣行为发生变更，都很方便去维护和拓展
要知道，后期需求经常会变更，用于维护和拓展的时间远远超过了开发的时间 ，所以，这种方式无异于给自己带来方便
策略模式 也可以简单概括为一组行为组，或者一组算法组，不同行为的实现即为不同的算法实现。
符合开闭原则，隐藏了算法的实现。
