java 策略（strategy）设计模式详解，和具体java 代码解析

首先一样上策略模式的UML类图：



分析： 一般抽象策略角色可以是一个interface，然后提供了不同的implements（ConcreteStrategyA，ConcreteStrategyB，ConcreteStrategyC）；
Context 环境角色 和 Strategy是聚合关系。
策略模式提供了数据 和 算法的分离，用不同的ConcreteStrategy去初始化Context的成员变量Strategy的实例（upcast），将实现 数据 和算法 的重组。

下面具体举一个例子

interface Print{
	void printsome();
}

class Print_1 implements Print{
	public void printsome(){
		System.out.println("print 1");
	}
}
class Print_2 implements Print{
	public void printsome(){
		System.out.println("Print 2");
	}
}
class Print_3 implements Print{
	public void printsome(){
		System.out.println("Print 3");
	}
}


class Strategy{
	Print print = null;
	Strategy(Print print){
		this.print = print;
	}
	
	Strategy(){}
	
	void printsome(){
		if(print == null){
			System.out.println("Print 0");
		}else{
			print.printsome();
		}
	}
}



class Go{
	public static void main(String args[]){
		Strategy strategy1 = new Strategy();
		Strategy strategy2 = new Strategy(new Print_1());
		Strategy strategy3 = new Strategy(new Print_2());
		Strategy strategy4 = new Strategy(new Print_3());
		strategy1.printsome();
		strategy2.printsome();
		strategy3.printsome();
		strategy4.printsome();
	}
}

interface Print 相当于Strategy，Print_1，Print_2,Print_3就是ConcreteStrategyX，
Context就是class Strategy。

当然 javaAPI中也有许多地方用到了Strategy design pattern，比如对于java.util.TreeSet 可聚合不同的“比较函数”。

对于 TreeSet<T>
如果T 实现了 Comparable<T>接口。
java.lang

public Comparable<T>{
     int compareTo(T o)
}

那么在构建TreeSet（红黑树），采用其来比较元素大小（默认），如果T没有实现Comparable<T>接口，或者想用其他的比较大小的算法，就向TreeSet<T>的构造函数中传入一个实现了Comparator接口的类的对象，那么在构建TreeSet的时候就会使用该比较算法去比较T的大小关系。这也就是是实现了，比较算法 和 TresSet的分离。一个TreeSet可以使用不同的大小比较算法，从而组织成不同的tree。

java.util

public Comparator<T>{
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

以下代码写了2个TreeSet<Integer> 在构造函数中一个没有传入Comparator<Integer>，即采用默认的Integer实现的Comparable<Integer>来比较Integer的大小（顺序），另一个传入了Comparator<Integer>,即用Comparator<Integer>来比较。

package learn;

import java.util.TreeSet;
import java.util.Comparator;
class Go{
	public static void main(String args[]){
		TreeSet<Integer> ts1 = new TreeSet<Integer>();
		TreeSet<Integer> ts2 = new TreeSet<Integer>(new Comparator<Integer>(){
			public int compare(Integer I1, Integer I2){
				return I2.compareTo(I1);
			}
		});
		ts1.add(10);
		ts1.add(7);
		ts1.add(8);
		ts2.add(10);
		ts2.add(7);
		ts2.add(8);
		System.out.println(ts1);
		System.out.println("--------------");
		System.out.println(ts2);
	}
}

最后给一个自定义类的结构，需要自己实现 Comparable<T>的代码:

package learn;

import java.util.TreeSet;
import java.util.Comparator;

class MyStyle implements Comparable<MyStyle>{
	int a = 0;
	int b = 0;
	MyStyle(int a, int b){
		this.a = a;
		this.b = b;
	}
	public int compareTo(MyStyle my){
		return a > my.a ? 1 : (a == my.a ? 0 : -1);
	}
	public String toString(){
		return "a = " + a + " b = " + b;
	}
}

class MyCompare implements Comparator<MyStyle>{
	public int compare(MyStyle ms1, MyStyle ms2){
		return ms1.b > ms2.b ? 1 : (ms1.b == ms2.b ? 0 : -1);
	}
}

class Go{
	public static void main(String args[]){
		TreeSet<MyStyle> st1 = new TreeSet<MyStyle>();
		TreeSet<MyStyle> st2 = new TreeSet<MyStyle>( new MyCompare());
		MyStyle my1 = new MyStyle(10,3), my2 = new MyStyle(3,10), my3 = new MyStyle(5, 19);
		st1.add(my1); st2.add(my1);
		st1.add(my2); st2.add(my2);
		st1.add(my3); st2.add(my3);
		System.out.println(st1);
		System.out.println(st2);
	}
}