标签：
策略模式:定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化.
实质：如何让算法和对象分开来，使得算法可以独立于使用它的客户而变化？
我们抛出一个具体的问题来看这个问题：多种方式比较对象的大小？
按照上面说的，我们要将对象和算法分开，所以我定义一个这样的接口（），用于规范一系列的比较类的方法
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的实现！
标签：
原文地址：http://www.cnblogs.com/think-in-java/p/4761696.html
