设计模式之策略模式

策略模式:定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化.

实质：如何让算法和对象分开来，使得算法可以独立于使用它的客户而变化？

我们抛出一个具体的问题来看这个问题：多种方式比较对象的大小？

按照上面说的，我们要将对象和算法分开，所以我定义一个这样的接口（），用于规范一系列的比较类的方法

public interface Comparator {
    int compare(Object o1, Object o2);
}

实现这个接口，写两个比较器。CatHeightcomparator和CatWeightComparator：

package com.bjsxt.dp.strategy;

public class CatHeightComparator implements java.util.Comparator<Cat> {

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

}

public class CatWeightComparator implements Comparator {

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

}

就是简单实现了compara方法，根据身高或者体重来比较大小。

看Cat类：

package com.bjsxt.dp.strategy;

public class Cat implements java.lang.Comparable<Cat> {
    private int height;
    private Comparator comparator = new CatHeightComparator();
    //private java.util.Comparator<Cat> comparator = new CatHeightComparator();
    public Comparator getComparator() {
        return comparator;
    }
    public void setComparator(Comparator comparator) {
        this.comparator = comparator;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }

    
    public Cat(int height, int weight) {
        super();
        this.height = height;
        this.weight = weight;
    }
    public int getWeight() {
        return weight;
    }
    public void setWeight(int weight) {
        this.weight = weight;
    }
    private int weight;
    
    @Override
    public String toString() {
        return height + "|" + weight;
    }
    @Override
    public int compareTo(Cat o) {
        return comparator.compare(this, o);
    }
}

定义一个实现Comparable接口的对象，通过set方式注入，然后在comparaTo中去调用注入的对象的compara方法。

定义一个DataSort类：

package com.bjsxt.dp.strategy;

import java.lang.Comparable;

public class DataSorter {

    public static void sort(Object[] a) {
        for(int i=a.length; i>0; i--) {
            for(int j=0; j<i-1; j++) {
                Comparable o1 = (Comparable)a[j];
                Comparable o2 = (Comparable)a[j+1];
                if(o1.compareTo(o2) == 1) {
                    swap(a, j , j+1);
                }
            }
        }
    }
    
    
    
    private static void swap(Object[] a, int x, int y) {
        Object temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }

    public static void sort(int[] a) {
        for(int i=a.length; i>0; i--) {
            for(int j=0; j<i-1; j++) {
                if(a[j] > a[j+1]) {
                    swap(a, j , j+1);
                }
            }
        }
    }

    private static void swap(int[] a, int x, int y) {
        int temp = a[x];
        a[x] = a[y];
        a[y] = temp;
    }

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

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

}

//一个测试方法
public class Test {
    public static void main(String[] args) {
        //int[] a = {9, 5, 3, 7, 1};
        Cat[] a = {new Cat(5, 5), new Cat(3, 3), new Cat(1, 1)};
        //Dog[] a = {new Dog(5), new Dog(3), new Dog(1)};
        DataSorter.sort(a);
        //java.util.Arrays.sort(a);
        DataSorter.p(a);
        
        
        
    }
}

今天比较累,不太想去解释这些问题。

说说核心理解吧！

策略模式的核心问题就是将算法和对象分开，实现可扩展！对象具体使用的东西，定义成策略类，通过注入的方式注入到对象，对象内部调用注入类的具体实现的方法，实现对象中策略可以轻松替换。

其实在jdk中也就是这样干的,我上面部分注释掉的内容，就是jdk的实现！