设计模式-策略模式

策略模式

1
2
3

鸭子问题
有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等)
显示鸭子的信息

传统方式解决问题

定义一个抽象类，用多个类去继承。

其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的
上面说的1的问题，其实是继承带来的问题:对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应
为了改进1问题，我们可以通过覆盖fly 方法来解决=>覆盖解决
问题又来了，如果我们有一个玩具鸭子ToyDuck，这样就需要ToyDuck去覆盖Duck的所有实现的方法=>解决思路策略模式

基本介绍

策略模式(Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来;第二、针对接口编程而不是具体类（定义了策略接口);第三、多用组合/聚合，少用继承（客户通过组合方式使用策略)。

策略模式的 UML 图

Context 是一个使用了某种策略的类。

解决问题

定义飞行接口

public interface FlyBehavior {

    public void fly();
}

不会飞行

public class NoFlyBehavior implements FlyBehavior{

    @Override
    public void fly() {
        System.out.println("不会飞行");
    }
}

飞的好

public class GoodFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println("飞行技术高超");
    }
}

飞的一般

public class BadFlyBehavior implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println("飞行技术一般");
    }
}

定义鸭子抽象类,在抽象类中集成策略接口，具体子类实现具体策略。

public abstract class Duck {

    //策略接口
    FlyBehavior flyBehavior;
    //其他属性，

    public Duck() {

    }

    public abstract void display();

    public void quack(){
        System.out.println("鸭子嘎嘎叫");
    }

    public void swim(){
        System.out.println("鸭子会游泳");
    }

    public void fly(){
        if (flyBehavior != null){
            flyBehavior.fly();
        }
    }
}

2个具体的context

public class PekingDuck extends Duck{

    public PekingDuck() {
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("北京鸭");
    }
}

public class WildDuck extends Duck{

    //传入
    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("野鸭");
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.fly();

        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.fly();
    }
}

源码

Arrays

JDK的arrays的Comparator使用了策略模式

1
2
3

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

实现Comparator接口，匿名类，这个对象是一个实现了策略接口的对象，实现的方法就是具体的策略方法。

comparator<Integer> comparator = new comparator<Integer>() {
	public int compare( Integer o1，Integer o2) {
		if (o1 > o2) {
			return 1;
        }else {
			return -1;
		}
	};
};
Arrays.sort(data,comparator)

这里就是使用率具体的策略接口进行排序。

public static <T> void sort(T[] a, Comparator<? super T> c) {
    if (c == null) {	//没有排序接口，就默认排序
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);	//使用策略对象c
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

注意事项

策略模式的关键是:分析项目中变化部分与不变部分
策略模式的核心思想是:多用组合/聚合少用继承;用行为类组合，而不是行为的继承。更有弹性
体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句(if..else if..else)
提供了可以替换继承关系的办法:策略模式将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展
需要注意的是:每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大