策略模式

策略模式

 直接上概念可能有些不太好理解，先来看个现成的此模式的应用吧，java中的Collections.sort(List<T>,Comparator<T>).

举个列子，医院的护士每年都会进行知识考试（四个科目），由考试的成绩决定每个科室内护士的能力排名，最终会影响年终奖的发放，医院现有四个科室，妇科，外科，内科，消化科，每个护士的总分由四个科目组成，不同的科室每个科目所占的比例不一样，比如说妇科的护士成绩：科目1*0.3+科目2*0.4+科目3*0.1+科目4*0.2。

首先会有一个Nurse(护士类)，这个类包含了护士的基本信息，所属科室，四个科目的成绩等等，代码如下： 

public class Nurse {
    private String id;
    private String name;
    private int age;
    private String departCode;
    private double scorekm1; // 科目1
    private double scorekm2; // 科目2
    private double scorekm3; // 科目3
    private double scorekm4; // 科目4
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getDepartCode() {
        return departCode;
    }
    public void setDepartCode(String departCode) {
        this.departCode = departCode;
    }
    public double getScorekm1() {
        return scorekm1;
    }
    public void setScorekm1(double scorekm1) {
        this.scorekm1 = scorekm1;
    }
    public double getScorekm2() {
        return scorekm2;
    }
    public void setScorekm2(double scorekm2) {
        this.scorekm2 = scorekm2;
    }
    public double getScorekm3() {
        return scorekm3;
    }
    public void setScorekm3(double scorekm3) {
        this.scorekm3 = scorekm3;
    }
    public double getScorekm4() {
        return scorekm4;
    }
    public void setScorekm4(double scorekm4) {
        this.scorekm4 = scorekm4;
    }
    public Nurse(String id,String name,int age,String departCode,double scorekm1,double scorekm2,double scorekm3,double scorekm4)
    {
        this.id=id;
        this.name=name;
        this.departCode=departCode;
        this.age=age;
        this.scorekm1=scorekm1;
        this.scorekm2=scorekm2;
        this.scorekm3=scorekm3;
        this.scorekm4=scorekm4;
    }
}

有了bean后，要对同一科室的护士进行成绩排序，我们还需要一个比较器，针对不同科室的成绩计算方式不一样，我们需要有不同的算法，这部分的算法我们就封装进比较器里面，所以需要建立四个实现comparator接口的具体类，代码如下：

 妇科比较器类：

public class CompareForfk implements Comparator<Nurse>{
    @Override
    public int compare(Nurse o1, Nurse o2) {
        double score01=o1.getScorekm1()*0.3+o1.getScorekm2()*0.2+o1.getScorekm3()*0.1+o1.getScorekm4()*0.4;
        double score02=o2.getScorekm1()*0.3+o2.getScorekm2()*0.2+o2.getScorekm3()*0.1+o2.getScorekm4()*0.4;
        if(score01<=score02){
            return -1;
        }else{
            return 1;
        }
    }
}

内科比较器类：

public class CompareFornk implements Comparator<Nurse>{
    @Override
    public int compare(Nurse o1, Nurse o2) {
        double score01=o1.getScorekm1()*0.3+o1.getScorekm2()*0.2+o1.getScorekm3()*0.4+o1.getScorekm4()*0.1;
        double score02=o2.getScorekm1()*0.3+o2.getScorekm2()*0.2+o2.getScorekm3()*0.4+o2.getScorekm4()*0.1;
        if(score01<=score02){
            return -1;
        }else{
            return 1;
        }
    }
}

外科比较器类:

public class CompareForwk implements Comparator<Nurse>{
    @Override
    public int compare(Nurse o1, Nurse o2) {
        double score01=o1.getScorekm1()*0.3+o1.getScorekm2()*0.4+o1.getScorekm3()*0.2+o1.getScorekm4()*0.1;
        double score02=o2.getScorekm1()*0.3+o2.getScorekm2()*0.4+o2.getScorekm3()*0.2+o2.getScorekm4()*0.1;
        if(score01<=score02){
            return -1;
        }else{
            return 1;
        }
    }
}

消化科比较器类:

public class CompareForxhk implements Comparator<Nurse> {

    @Override
    public int compare(Nurse o1, Nurse o2) {
        double score01=o1.getScorekm1()*0.4+o1.getScorekm2()*0.3+o1.getScorekm3()*0.2+o1.getScorekm4()*0.1;
        double score02=o2.getScorekm1()*0.4+o2.getScorekm2()*0.3+o2.getScorekm3()*0.2+o2.getScorekm4()*0.1;
        if(score01<=score02){
            return -1;
        }else{
            return 1;
        }
    }
}

这些基础类都建好了之后，剩下的就是客户端的事啦，比如说对妇科的护士按成绩排序。

Collections.sort(listForFk,new CompareForfk());

看到这里，应该有一个大概的了解了，那么开始了解下策略模式的概念吧。

概念：将一组算法分别封装起来，在使用这些算法时可以让他们相互替换，算法的相互替换独立于客户端的使用。

模式中有三种角色：

一 抽象策略类：所有算法实现的接口

二 具体策略类：具体的算法封装的类

三 环境角色：持有对抽象策略类的引用，由客户端程序调用

大家可以看下Collections.sort方法源代码，可以看到其实最终仍然是listForFk.sort(Comparator<T> c),所以说上面列子中的环境角色就是listForFk。

可能我们对环境角色持有对抽象策略类的引用这一点有一点小小的疑问，因为环境角色既然持有对抽象策略类的引用，那么抽象策略类应该是环境角色的一个属性，即两者之间应该是组合的关系，而上面的例子中，Comparator只是listForFk的一个方法的参数，实际上没有必要这么严格的对比，环境角色持有抽象策略类的引用这只是个抽象的说法，宽松一点来讲，在调用sort方法的时候，listForFk其实也已经持有了比较器的引用，如果没有持有比较器的引用，那么也就没有排序的依据了。

其实，仔细想想，多态的概念也是适用于策略模式的，比如说一个接受父类为参数的方法，当我们每次调用方法的时候，传入一个实际指向子类的父类引用，这样也可以实现子类方法的相互替换，同样独立于客户端的使用。

对于客户端而言，不同的情况下，程序员会选择不同的具体策略类，但是从使用策略类上来讲，客户端的使用方式是一样的，这算是策略模式的优点之一了。但是这有个前提，即程序员要知道所有的具体策略类，知道什么时候用哪个，从这方面来讲，这算是策略模式的一个缺点了，那么能不能改进下这个不好的地方呢，答案就是工厂模式，继续拿之前的护士成绩排序为例。

我们知道，护士成绩的排序是根据科室来的，不同的科室有不同的计算方法，那么我们可以根据科室作为工厂生产对象（比较器类）的依据，代码如下：

public class ComparatorFactory {
    private Map<String, Comparator<Nurse>> map=new HashMap<String,Comparator<Nurse>>(){
        {
            put("NK", new CompareFornk());
            put("WK", new CompareForwk());
            put("FK", new CompareForfk());
            put("XHK", new CompareForxhk());
        }
    };
    
    public Comparator<Nurse> getComparatorForDepart(Nurse nurse) {
        String departCode=nurse.getDepartCode().toUpperCase();
        return map.get(departCode);
    }
}

工厂类实现后，我们再看下客户端的调用，代码如下:

public class comparator {

    public static void main(String[] args) {
        
        List<Nurse> listForFk=new ArrayList<Nurse>(){
            {
                add(new Nurse("1","eileen",20,"FK",80,76,83,56));
                add(new Nurse("2","shelly",21,"FK",90,76,83,56));
                add(new Nurse("3","bailing",23,"FK",75,76,83,56));
            }
        };
        Collections.sort(listForFk,new ComparatorFactory().getComparatorForDepart(listForFk.get(0)));
        Iterator<Nurse> iterator=listForFk.iterator();
        while(iterator.hasNext()){
            Nurse nurse=iterator.next();
            System.out.println(nurse.getName());
        }
    }
}

其实加深对模式的理解，还是需要多找些例子来学习，懂了并不代表会了，多思考，多学习。