设计模式--策略模式--简记

策略模式（Strategy Pattern）：

　　一个类的行为或算法可以在运行是更改。

　　比如：要实现一个通用的比较大小的类方法，单个对象比较大小的策略可能会发生改变，可能会出现多种比较策略，我们可定义一个比较策略接口，对象类中比较的大小的方法，可以通过更改策略实现对象，来进行替换。

优点：

　　算法可以自由切换、避免多重条件判断、扩展性好

缺点：

　　策略类会增多，策略类需要对外暴露

例：定义一个猫类

package cn.qf.lean.dp;

import java.util.Comparator;

/*
 * 定义一只猫类，类中含比较猫的大小的方法
 * 猫大小的比较含多个维度的比较策略
 */

public class Cat implements Comparable<Cat> {
    
    private int height;
    private int weight;
    //通过高度的比较策略比较猫的大小
    private Comparator<Cat> comparator = new CatHeightComparator();
    //通过宽度的比较策略比较猫的大小
//    private Comparator<Cat> comparatorW = new CatWeightComparator();
        
    public Cat(int i, int j) {
        this.height = i;
        this.weight = j;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int getWeight() {
        return weight;
    }
    public void setWeight(int weight) {
        this.weight = weight;
    }
    
    public Comparator<Cat> getComparator() {
        return comparator;
    }
    public void setComparator(Comparator<Cat> comparator) {
        this.comparator = comparator;
    }
    
    @Override
    public int compareTo(Cat o) {
        return comparator.compare(this, o);
    }
    
    @Override
    public String toString() {
        return height + "|" + weight;
    }

}

猫大小比较的两种策略

package cn.qf.lean.dp;

import java.util.Comparator;

/*
 * 通过比较猫的高度的策略，比较猫的大小
 */

public class CatHeightComparator implements Comparator<Cat> {

    

    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.getHeight() > o2.getHeight()) return 1;
        else if(o1.getHeight() < o2.getHeight()) return -1;
        else return 0;
    }

}

package cn.qf.lean.dp;

import java.util.Comparator;

/*
 * 通过比较猫的宽度的策略，比较猫的大小
 */

public class CatWeightComparator implements Comparator<Cat> {


    @Override
    public int compare(Cat o1, Cat o2) {
        if(o1.getWeight() > o2.getWeight()) return 1;
        else if(o1.getWeight() < o2.getWeight()) return -1;
        else return 0;
    }

}

比较类

package cn.qf.lean.dp;

/*
 * 比较算法
 */

public class DataSorter {
    
    public static void sort(Comparable[] a) {
        
        for(int i=a.length; i>0; i--) {
            for(int j=0; j<i-1; j++) {
                Comparable c1 = (Comparable)a[j];
                Comparable c2 = (Comparable)a[j+1];
                if(c1.compareTo(c2) == 1) {
                    swap(a, j, j+1);
                }
            }
        }
    }
    
    
    private static void swap(Object[] a, int x, int y) {
        // TODO Auto-generated method stub
        Object temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }



    public static void p(Object[] a) {
        
        for(int i=0; i<a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.print("
");
    }

}

测试

package cn.qf.lean.dp;

public class Test {
    
    public static void main(String[] args) {
        
        Cat[] a = {new Cat(5, 5), new Cat(3, 3), new Cat(1,1)};
        DataSorter.sort(a);
        DataSorter.p(a);
        
    }
}