Android 策略模式

源码地址

介绍

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

使用场景

• 针对同一类型的多种处理方式，仅仅是具体行为有差别时。
• 需要安全地封装多种同一类型的操作时。
• 出现同一抽象类有多个子类，而又需要使用 if-else 或者 switch-case 来选择具体子类时。

角色介绍

• Context——用来操作策略的上下文环境；
• Strategy——策略的抽象；
• ConcreteStrategyA，ConcreteStrategyB——具体的策略实现。

简单实现

需求：下面以坐公交工具的费用计算来演示。

第一个版本的代码：

public class PriceCalculator {
    //公交车类型
    private static final int BUS = 1;
    //地铁类型
    private static final int SUBWAY = 2;

    /**
     * 公交车，十公里之内一元钱，超过十公里之后每加一元钱可以乘5公里
     * @param km   公里
     * @return
     */
    private int busPrice(int km) {
        //超过十公里的总距离
        int extraTotal = km - 10;
        //超过的距离是5公里的倍数
        int extraFactor = extraTotal / 5;
        //超过的距离对5公里取余
        int fraction = extraTotal % 5;
        //价格计算
        int price = 1 + extraFactor * 1;
        return fraction > 0 ? ++price : price;
    }

    /**
     * 6公里(含)内3元；6~12公里(含)4元；12~22公里(含)5元；22~32公里(含)6元；
     * @param km    公里
     * @return
     */
    private int subwayPrice(int km) {
        if (km <= 6) {
            return 3;
        } else if (km <= 12) {
            return 4;
        } else if (km <= 22) {
            return 5;
        } else if (km <= 32) {
            return 6;
        }
        //其他距离简化为7元
        return 7;
    }

    private int calculatePrice(int km, int type) {
        if (type == BUS) {
            return busPrice(km);
        } else if (type == SUBWAY) {
            return subwayPrice(km);
        }
        return 0;
    }

    public static void main(String[] args) {
        PriceCalculator calculator = new PriceCalculator();
        System.out.println("坐16公里的公交车票价为：" + calculator.calculatePrice(16, BUS));
        System.out.println("坐16公里的地铁票价为：" + calculator.calculatePrice(16, SUBWAY));
    }
}

当增加一种出行方式时，如出租车，那么就需要在 PriceCalculator 中增加一个方法来计算出租车出行的价格，并且在 calculatePrice 函数中增加一个判断，新增代码大致如下：

public class PriceCalculator {
    //公交车类型
    private static final int BUS = 1;
    //地铁类型
    private static final int SUBWAY = 2;
    //出租车类型
    private static final int TAXI = 3;

    private int taxiPrice(int km) {
        return km * 2;
    }
  
    private int calculatePrice(int km, int type) {
        if (type == BUS) {
            return busPrice(km);
        } else if (type == SUBWAY) {
            return subwayPrice(km);
        } else if (type == TAXI) {
            return taxiPrice(km);
        }
        return 0;
    }
}

当修改计算方式或者增加出行方式时，有需要增加 if-else 代码，这样会使得代码变得难以维护。

下面为策略模式实现代码：

1. 计算接口

   public interface CalculateStrategy {
       /**
        * 按距离来计算价格
        * @param km    公里
        * @return  返回价格
        */
       int calculatePrice(int km);
   }
   

2. 公交车价格计算策略

   public class BusStrategy implements CalculateStrategy {
       /**
        * 公交车，十公里之内一元钱，超过十公里之后每加一元钱可以乘5公里
        * @param km   公里
        * @return
        */
       @Override
       public int calculatePrice(int km) {
           //超过十公里的总距离
           int extraTotal = km - 10;
           //超过的距离是5公里的倍数
           int extraFactor = extraTotal / 5;
           //超过的距离对5公里取余
           int fraction = extraTotal % 5;
           //价格计算
           int price = 1 + extraFactor * 1;
           return fraction > 0 ? ++price : price;
       }
   }
   

3. 地铁价格计算策略

   public class SubwayStrategy implements CalculateStrategy {
       /**
        * 6公里(含)内3元；6~12公里(含)4元；12~22公里(含)5元；22~32公里(含)6元；
        * @param km    公里
        * @return
        */
       @Override
       public int calculatePrice(int km) {
           if (km <= 6) {
               return 3;
           } else if (km <= 12) {
               return 4;
           } else if (km <= 22) {
               return 5;
           } else if (km <= 32) {
               return 6;
           }
           //其他距离简化为7元
           return 7;
       }
   }
   

4. 出行计算器

   public class TranficCalculator {
       private CalculateStrategy mStrategy;
       public void setStrategy(CalculateStrategy strategy) {
           mStrategy = strategy;
       }
   
       public int calculatePrice(int km) {
           return mStrategy.calculatePrice(km);
       }
   
       public static void main(String[] args) {
           TranficCalculator calculator = new TranficCalculator();
           calculator.setStrategy(new BusStrategy());
           System.out.println("公交车乘坐16公里的价格：" + calculator.calculatePrice(16));
   
           calculator.setStrategy(new SubwayStrategy());
           System.out.println("地铁乘坐16公里的价格：" + calculator.calculatePrice(16));
   }
   

   如果需要增加一个出租车计算策略类，代码如下：

5. 出租车计算策略

   public class TaxiStrategy implements CalculateStrategy {
       @Override
       public int calculatePrice(int km) {
           return km * 2;
       }
   }
   

6. 出行价格计算器

   public class TranficCalculator {
       private CalculateStrategy mStrategy;
       public void setStrategy(CalculateStrategy strategy) {
           mStrategy = strategy;
       }
   
       public int calculatePrice(int km) {
           return mStrategy.calculatePrice(km);
       }
   
       public static void main(String[] args) {
           TranficCalculator calculator = new TranficCalculator();
           calculator.setStrategy(new TaxiStrategy());
           System.out.println("出租车乘坐16公里的价格：" + calculator.calculatePrice(16));
       }
   }
   

从上面可以看出，使用 if-else 来解决问题，优点是实现简单，层级单一；但缺点也很明显，即代码臃肿，逻辑复杂，难以升级与维护，没有结构可言。

后者是通过建立抽象，将不同的策略构建成一个具体的策略实现，通过不同的策略实现算法替换。在简化逻辑、结构的同时，增强了系统的可读性、稳定性、可扩展性。

Android源码中的实现

TimeInterpolator 时间插值器，用在属性动画中。

总结

• 优点
  1. 结构清晰明了，使用简单直观；
  2. 耦合度相对而言较低，扩展方便；
  3. 操作封装也更彻底，数据更为安全。
• 缺点
  1. 随着策略的增加，子类也会变得繁多。