原则:将经常改变的和不经常改变的分离设计 ,面向接口而非面向实现编程,多组合,少继承
举个例子 现在有电影院,一年四季根据季节去打折,假设有一个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
无论是哪一个季节折扣行为发生变更,都很方便去维护和拓展
要知道,后期需求经常会变更,用于维护和拓展的时间远远超过了开发的时间 ,所以,这种方式无异于给自己带来方便
策略模式 也可以简单概括为一组行为组,或者一组算法组,不同行为的实现即为不同的算法实现。
符合开闭原则,隐藏了算法的实现。