设计模式——策略对象

策略模式

• 定义了算法家族，分别封装起来，让他们之间可以互相替代，此模式让算法的变法，不会影响到使用算法的客户

• 当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句

• 简单工厂模式只是解决对象的创建问题，面对算法的时常变动，应该用策略模式

• 面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同该属性和功能的对象的抽象集合才是类

• 封装变化

  例子：超时收银，可能会有不能收银方式，打折、满多少送多少、积分等等。这里不变的是收银，变的是收银的具体方式.

  /** * 现金收费抽象类   定义接口   抽象出不变的 */public interface CashSuper {    double acceptCash(double money);}// 具体的算法实现public class CashReturn implements 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 ret = money;        if (money > moneyCondition) {            ret = money - Math.floor(money / moneyCondition) * moneyReturn;        }        return ret;    }}

  // 具体的算法实现
  public class CashRebate implements CashSuper {
  private double moneyRebate;

  public CashRebate(double moneyRebate) {    this.moneyRebate = moneyRebate;}@Overridepublic double acceptCash(double money) {    return money * moneyRebate;}

  }
  // 具体的算法实现
  public class CashNormal implements CashSuper{
  @Override
  public double acceptCash(double money) {
  return money;
  }
  }
  // 上下文 将变化swtich从客户端分离
  public class CashContext {
  CashSuper cs = null;

  public CashContext(int type) {    switch (type) {        case 1:            cs = new CashNormal();            break;        case 2:            cs = new CashReturn(300, 100);            break;        case 3:            cs = new CashRebate(0.8);            break;    }}public double getResult(double money){    return cs.acceptCash(money);}

  }
  // 客户端
  public static void main(String[] args) {
  CashContext cs = new CashContext(2);// 1 3 客户端只接触了context,上下文

  double result = cs.getResult(500);System.out.println(result);

  }