java策略模式

1)   找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

2)   针对接口编程，而不是针对实现编程。

3)   多用组合，少用继承。

3策略模式的编写步骤
1)    对策略对象定义一个公共接口。2)    编写策略类，该类实现了上面的公共接口。3)    在使用策略对象的类中保存一个对策略对象的引用。4)    在使用策略对象的类中，实现对策略对象的set和get方法（注入）或者使用构造方法完成赋值。4，实际例子：

《head first <span lang="EN-US" style="" font-size:10.5pt;"="">Design Pattern》的例子（简化后）：模拟一个鸭子游戏，游戏中有三种鸭子（绿头鸭MallardDuck, 红头鸭RedheadDuck

，橡皮鸭RubberDuck，诱饵鸭DecoyDuck），鸭子们都会游泳，外表各不相同，同类型鸭子叫声相同，绿头鸭和红头鸭会飞会叫，橡皮鸭不会飞但会叫，诱饵鸭不会飞不会叫，请设计这个游戏。

1，我们可能这么设计：
该设计的缺陷是：
绿头鸭和红头鸭叫声相同，但是quack()却无法复用，如果该行为要修改，那么修改该行为非常麻烦，你必须得往下追踪并在每一个定义此行为的类中修改它，这将是可怕的。
解决方法：分开变化的与不会变化的部分；体现（设计原则1）
Duck类内的fly()和quack()会随着鸭子的不同而改变，将这两个行为从Duck类中分开，形成“算法族”。
整体类结构如下所示：
详细代码：
飞行的接口：
interface FlyBehavior{
public void fly();
}
两个飞行类的实现：
class FlyWithwings implements FlyBehavior{
public void fly(){
System.out.println("can fly");
}
}
class FlyNoWay implements FlyBehavior{
public void fly(){
System.out.println("can not fly");
}
}
叫声的接口：
interface QuackBehavior{
public void quack();
}
三个叫声行为的实现：
class Quack implements QuackBehavior{
public void quack(){
System.out.println("guagua");
}
}
class Squeak implements QuackBehavior{
public void quack(){
System.out.println("zhizhi");
}
}
class MuteQuack implements QuackBehavior{
public void quack(){
System.out.println("can not fly");
}
}
鸭子的基类：
abstract class Duck {
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public abstract void display();
public void performFly(){
flyBehavior.fly();
}
public void performQuack(){
quackBehavior.quack();
}
public void swim(){
System.out.println("All ducks can swim");
}
}
在java的 Comparator使用的就是该设计模式，就是不改变对象本身，而是用一个策略对象改变它的行为；以下模拟下它的实现过程。
题目：人有年龄和身高两种属性，现在要对不同的人排序，可以按年龄也可以按身高。
人物类定义：
class perSon {
int Age;
int weigth;

perSon(int Age, int weigth) {
this.Age = Age;
this.weigth = weigth;
}
public void printinfo(){
System.out.println("age:"+Age+"  weight:"+ weigth);
}
}
MyComparator接口：
interface MyComparator<T> {
public int compare(T o1, T o2);
}
接下来是两种比较策略，继承了接口MyComparator
class perSonSortWithweigth implements MyComparator<perSon> {

@Override
public int compare(perSon o1, perSon o2) {
// TODO Auto-generated method stub
// TODO Auto-generated method stub
if (o1.weigth > o2.weigth) {
return 1;
} else if (o1.weigth == o2.weigth) {
return 0;
} else {
return -1;
}

}
}

class perSonSortWithAge implements MyComparator<perSon> {

@Override
public int compare(perSon o1, perSon o2) {
// TODO Auto-generated method stub
if (o1.Age > o2.Age) {
return 1;
} else if (o1.Age == o2.Age) {
return 0;
} else {
return -1;
}

}
}
接下来模拟arrays类（api中的arrays要复杂的多）；
class myArrays {
public static <T> void sort(T[] arr, MyComparator<? super T> c) {
T temp;
// 简单的冒泡排序
// 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
// 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。最后的元素应该会是最大的数。
// 针对所有的元素重复以上的步骤，除了最后一个。
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (c.compare(arr[j + 1], arr[j]) >= 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
测试如下：
public class test {
public static void main(String[] args) {
perSon[] persons=new perSon[]{new perSon(1,2),new perSon(2,3),new perSon(3,0)};
myArrays.sort(persons,new perSonSortWithAge());
for(int i=0;i<persons.length;i++){
persons[i].printinfo();
}
myArrays.sort(persons, new perSonSortWithweigth());
for(int i=0;i<persons.length;i++){
persons[i].printinfo();
}

}
}
既然提到了Comparator，那么顺便介绍下Comparable接口吧；对于上边的题目，如果用Comparable接口该这么实现：
MyComparable接口定义如下：
interface MyComparable<T> {
int compareTo(T o);
}
人物类继承接口：
class person implements MyComparable {
int Age;
int weigth;

person(int Age, int weigth) {
this.Age = Age;
this.weigth = weigth;
}

public void printinfo() {
System.out.println("age:" + Age + "  weight:" + weigth);
}

@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
if(Age > ((person)o).Age){
return 1;
}else if(Age == ((person)o).Age){
return 0;
}else{
return -1;
}
}
}
类arrays
class MyArrays{
public static void sort(Object[] arr){
Object temp;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (((MyComparable)arr[j + 1]).compareTo(arr[j])  >= 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
测试代码为：
public class test1 {
public static void main(String[] args) {
person[] persons=new person[]{new person(1,2),new person(2,3),new person(3,0)};
MyArrays.sort(persons);
for(int i=0;i<persons.length;i++){
persons[i].printinfo();
}
}
}
那么他们的区别如下所示：
Comparable 和 Comparator 都是用来实现集合中元素的比较、排序的。只是 Comparable 是在集合内部定义的方法实现的排序，而Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。Comparator位于包java.util下，而Comparable位于包 java.lang下一.Comparable 是一个对象，本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作，已经实现了Comparable接口）自定义的类要在加入list容器中后能够排序，可以实现Comparable接口，在用Collections类的sort方法排序时，如果不指定Comparator，那么就以自然顺序排序，这里的自然顺序就是实现Comparable接口设定的排序方式。二.Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。可以说一个是自已完成比较，一个是外部程序实现比较的差别而已。