Android设计模式---策略模式

一. 定义

策略模式定义了一系列算法，并将每一个算法封装起来，而且是他们之间可以相互切换。

二. 实现(3大角色)

1. 策略的抽象(Strategy)
2. 具体的策略实现(ConcreteStrategy)
3. 用来操作策略的上下文环境(Context)

下面我们以计算不同交通工具的车费来简单看看策略模式的实现

1.策略的抽象

public interface CalculateStragety {
    /**
     * 根据公里数计算价格
     * @param km 公里数
     * @return 价格
     */
    int calculatePrice(int km);
}

2. 具体的策略实现

/**
 * 公交车
 */
public class BusStragety implements CalculateStragety {
    @Override
    public int calculatePrice(int km) {
        //具体计算方法(省略)
        return 10;
    }
}

/**
 * 出租车
 */
public class TaxiStragety implements CalculateStragety {
    @Override
    public int calculatePrice(int km) {
        //省略具体算法
        return 20;
    }
}

3. 用来操作策略的上下文环境

public class TrafficCalculator {

    private CalculateStragety mCalculateStragety;

    /**
     * 根据需要注入相应的策略
     * @param calculateStragety 注入的策略
     */
    public void setCalculateStragety(CalculateStragety calculateStragety) {
        mCalculateStragety = calculateStragety;
    }

    /**
     * 把具体的计算委托给注入的策略
     * @param km 公里数
     * @return 车费
     */
    public int calculatePrice(int km) {
        return mCalculateStragety.calculatePrice(km);
    }
}

使用

public class Main {
    public static void main(String[] args) {
        TrafficCalculator trafficCalculator = new TrafficCalculator();
//        trafficCalculator.setCalculateStragety(new BusStragety());
        trafficCalculator.setCalculateStragety(new TaxiStragety());
        int price = trafficCalculator.calculatePrice(66);
        System.out.print("price="+price);
    }
}

算法可以随意切换, 符合里氏替换原则.
如果要增加一个算法, 只需新增一个子类即可, 符合开闭原则.

三. 优缺点

优点:
① 很好地展示了开闭原则和里氏替换原则,
② 算法可以自由切换
③ 避免使用多重条件判断
④ 耦合低, 扩展性良好

缺点:
① 随着策略的增加, 子类会越来越多
② 所有策略类都需要对外暴露, 也就是"白盒子".

四. 应用场景

一个对象动态地在几种算法中选择一种时

1. android源码中.
Animation中的插值器

 Animation animation = new AlphaAnimation(1,0);
 animation.setInterpolator(new AccelerateDecelerateInterpolator());

2. Java中Comparator.
对象排序功能实现

抽象策略类 Comparator

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
 }

具体策略类 SortComparator

public class SortComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        //忽略具体实现
        return 1;
    }
}

使用

public static void main(String[] args) {

        Student stu[] = {
                new Student("张三" ,23),
                new Student("李四" ,26)};
        Arrays.sort(stu,new SortComparator());
        System.out.println(Arrays.toString(stu));

        List<Student> list = new ArrayList<>(3);
        list.add( new Student("zhangsan" ,31));
        list.add( new Student("lisi" ,30));
        Collections.sort(list,new SortComparator());
        System.out.println(list);

    }