设计模式-策略模式

概述

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

UML

实现

Strategy.Java，策略类，定义算法的公共接口。

public abstract class Strategy {

   // 算法方法

   public abstract void algorithmInterface();

}

 

ConcreteStrategyA.java，算法A，封装了具体算法，继承Strategy。

public class ConcreteStrategyA extends Strategy {

   @Override

   public void algorithmInterface() {

      System.out.println("算法A实现");

   }

}

 

ConcreteStrategyB.java，算法B。

public class ConcreteStrategyB extends Strategy {

   @Override

   public void algorithmInterface() {

      System.out.println("算法B实现");

   }

}

 

ConcreteStrategyC.java，算法C。

public class ConcreteStrategyC extends Strategy {

   @Override

   public void algorithmInterface() {

      System.out.println("算法C实现");

   }

}

 

Context.java，上下文环境，维护Strategy引用。

public class Context {

   private Strategy strategy;

   public Context(Strategy strategy) {

      this.strategy = strategy;

   }

   public void contextInterface() {

      strategy.algorithmInterface();

   }

}

 

StrategyTest.java，客户端代码。

public class StrategyTest {

   public static void main(String[] args) {

      Context context;

      context = new Context(new ConcreteStrategyA());

      context.contextInterface();

      context = new Context(new ConcreteStrategyB());

      context.contextInterface();

      context = new Context(new ConcreteStrategyC());

      context.contextInterface();

   }

}

优缺点

优点

1、   提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)，还比继承更灵活(算法独立，可以任意扩展)；

2、   避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展；

3、   遵守大部分GRASP原则和常用设计原则，高内聚、低偶合；

4、   易于进行单元测试，各个算法区分开，可以针对每个算法进行单元测试；

5、   ……

缺点

1、   因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量；

2、   选择何种算法需要客户端来创建对象，增加了耦合，这里可以通过与工厂模式结合解决该问题；

3、   程序复杂化。

实例

需求

商场收银系统，实现对不同情况(正常收费、折扣收费、返利收费等)的收费。

实现

CashSuper.java，现金收费父类。

/* 现金收费父类 */

public abstract class CashSuper {

   /* 收取现金方法，参数为商品原价，返回值为当前价 */

   public abstract double acceptCash(double money);

}

 

CashNormal.java，正常收费。

/* 正常收费 */

public class CashNormal extends CashSuper {

   @Override

   public double acceptCash(double money) {

      return money;

   }

}

 

CashRebate.java，打折收费。

/* 打折收费 */

public class CashRebate extends CashSuper {

   /* 折扣率 */

   private double moneyRebate;

  

   public CashRebate(double moneyRebate) {

      this.moneyRebate = moneyRebate;

   }

 

   @Override

   public double acceptCash(double money) {

      return money * moneyRebate;

   }

}

 

CashReturn.java，返利收费。

/* 返利收费 */

public class CashReturn extends CashSuper {

   /* 返利满足条件 */

   private double moneyCondition;

   /* 满足条件后返回值 */

   private double moneyReturn;

  

   public CashReturn(double moneyCondition, double moneyReturn) {

      this.moneyCondition = moneyCondition;

      this.moneyReturn = moneyReturn;

   }

 

   @Override

   public double acceptCash(double money) {

      double result = 0;

      result = money - Math.floor(money / moneyCondition) * moneyReturn;

      return result;

   }

}

 

CashContext.java，维护CashSuper对象。

public class CashContext {

 

   private CashSuper cs;

  

   public CashContext(CashSuper cs) {

      this.cs = cs;

   }

  

   public double getResult(double money) {

      return cs.acceptCash(money);

   }

}

 

CashTest.java，客户端。

public class CashTest {

   public static void main(String[] args) {

      double money = 500;

      CashContext context;

      context = new CashContext(new CashNormal());

      double normal = context.getResult(money);

      System.out.println("正常收费：" + normal);

      context = new CashContext(new CashRebate(0.8));

      double rebate = context.getResult(money);

      System.out.println("八折收费：" + rebate);

      context = new CashContext(new CashReturn(200, 100));

      double retur = context.getResult(money);

      System.out.println("满200返100：" + retur);

   }

}

总结

策略模式和简单工厂模式的区别

相同点

1、   都是用到了封装、继承、多态；

2、   都抽出一个接口或者抽象类，针对不同的情况，有不同的实现类。

不同点

1、   使用方式不同，工厂是静态的，策略的上下文是需要创建对象的；

2、   工厂产生的是对象，不同情况下产生不同的对象；

3、   策略产生的是策略，或者说是算法，不同情况下使用不同的算法。

结论

无论何种设计模式，都是基于面相对象的三大特性，即封装、继承、多态。