九、策略模式Strategy（行为型模式）

定义一系列算法，封装每个算法，使它们可以互换，策略允许算法随使用它的客户的不同而不同。

不同策略类别之间的变与不变的分离，将不变部分写入Strategy抽象类别里。

将Context类别里的不同策略（即会变部分）分离出来，而委托不同的策略类别去实现之。

public class Test {

   public static void main(String[] args) {
      //-----------------//
      int[] a={1,3,2,6,4};
      DataSorter.sort(a);
      DataSorter.p(a);
      //---------Comparable接口只能一种实现，将来不能随意扩展，比如升序变降序--------//
      Cat[] cs={new Cat(3, 4),new Cat(1, 2),new Cat(2, 5)};
      DataSorter.sort(cs);
      DataSorter.p(cs);
      //---------策略模式（灵活）--------//
      Cat[] cs2={new Cat(3, 4),new Cat(1, 2),new Cat(2, 5)};
      DataSorter.sort(cs2);
      DataSorter.p(cs2);
   }
}

class DataSorter{

   public static void sort(Object[] a) {
      for(int i=0;i<a.length;i++){
        for(int j=1;j<a.length-i;j++){
           Comparable c1=(Comparable) a[j-1];
           Comparable c2=(Comparable) a[j];
           if(c1.compareTo(c2)==1){
              Object t=a[j];
              a[j]=a[j-1];
              a[j-1]=t;
           }
        }
      }
   }

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

   public static void p(Object[] a) {
      for (Object i : a) {
        System.out.print(i);
      }
      System.out.println("");
   }

   public static void p(int[] a) {
      for (int i : a) {
        System.out.print(i);
      }
      System.out.println("");
   }

}

interface Comparable{
   public int compareTo(Object o);
}

class Cat implements Comparable{
   private int height;
   private int weight;
   private Comparator comparator =new CatWeightComparator();
   @Override
   public String toString() {
      return"Cat [height=" + height + ", weight=" + weight + "]";
   } 

   public Cat(int height, int weight) {
      super();
      this.height = height;
      this.weight = weight;
   }

   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 getComparator() {
      return comparator;
   }

   public void setComparator(Comparator comparator) {
      this.comparator = comparator;
   }

   @Override
   publicint compareTo(Object o) {
      /*if(o instanceof Cat){
        Cat c = (Cat)o;
        if(this.getHeight()>c.getHeight())
           return 1;
        else if(this.getHeight()<c.getHeight())
           return -1;
        else
           return 0;
      }
      //应该是抛异常，简单的返回-100；
      return -100;*/
      //---------策略模式（灵活）--------//
      return comparator.compare(this, o);
   }
}

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

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

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.getWeight()<c2.getWeight())
        return 1;
      else return 0;
   }
}