java设计模式--策略模式

java设计模式---策略模式

策略模式使用场景

主要是在遇到如何让算法和对象分开来，使得算法可以独立于使用它的客户而变化？
采用策略模式主要思想：
把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口，然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为

例子

专门用于排序的类DataSorter中实现对所有A类、B类....等等进行排序

初步想法

DataSorter.java的代码如下

public class DataSorter {

   /* public static void sort(A a){

    }

    public static void sort(B a){

    }

    public static void sort(C c){

    }*/
    }

基于上面的做法会造成DataSorter的可扩展性差，要支持对新类的排序时，要修改代码

更好的办法

更好的思路是:既然DataSorter是要根据不同的类的采取不同的方法实现排序，那么具体实现排序的方法交由子类去实现，且都实现同一个接口Comparable，那么DataSorter只需对Comparable排序，而无需理会具体要排序的是

类之间的关系

1

具体代码如下：

1.DataSorter

/**
 *目标：专门用于排序的类DataSorter中实现对所有A类、B类....等等进行排序
 * 如果直接在Datasorter中使用对A、B、C类排序这样扩展行差,要支持对新类的排序时，要修改代码
 * Created by td on 2017/8/29.
 * 更好的思路是:：既然DataSorter是要根据不同的类的采取不同的方法实现排序，那么具体实现排序的方法交由子类去实现，且都实现同一个接口Comparable，那么DataSorter只需对Comparable排序，而无需理会具体要排序的是
 */
public class DataSorter {
    public static void sort(Comparable [] a) {

        int index;                          //保存每次比较,最大值的下标;

        for(int i = 1; i < a.length; i++){   //控制外循环次数
            index = 0;
            for(int j = 1; j <= a.length - i ; j++){
                if(a[j].compareTo(a[index]) == 1){
                    index = j;
                }
            }
            swap(a, index, a.length -i);
        }
    }


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

    }


    //输出数组元素
    public static void show(Comparable[] a) {
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);
        }
    }

   /* public static void sort(A a){

    }

    public static void sort(B a){

    }

    public static void sort(C c){

    }*/

/*
    //冒泡排序法
    //主要思路：按升序排序，数组元素两两比较，大的立即排后面
    public static void bubbleSort(int[] a) {

       for (int i=0;ia[j]){
                   index = j;
               }
           }

           if (index!=i){
               swap(a,i,index);
           }
       }




    }


    //直接选择排序法
    //主要思路：按升序排序，每次循环找出最小数，把他放到第i位置上
    public static void selectSort(int[] array) {

    }


    //交换数组元素
    private static void swap(int[] a, int x, int y) {
        int tmp = a[x];
        a[x] = a[y];
        a[y] = tmp;
    }

    //输出数组元素
    public static void show(int[] a) {
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);
        }
    }

    public static void main(String[] args) {
        int[] a = {1,4,0,5,1,2,3,10,9,2};
        bubbleSort(a);
        show(a);
    }
*/

}

2.定义排序接口Comparable

/**
 * Created by td on 2017/8/29.
 */
public interface Comparable {
    public int compareTo(T o);
}

3.定义student并实现Comparable

/**
 * Created by td on 2017/8/29.
 */
public class Student implements Comparable {

    private int mark;

    public int getMark() {
        return mark;
    }

    public void setMark(int mark) {
        this.mark = mark;
    }

    public Student(int mark) {
        super();
        this.mark = mark;
    }

    @Override
    public String toString() {
        return "student" +mark+" ";
    }

    @Override
    public int compareTo(Student o) {
        if(this.mark > o.getMark()){
            return 1;
        }else if(this.mark == o.getMark()){
            return 0;
        }else{
            return -1;
        }
    }
}

4.定义Teacher并实现Comparable

public class Teacher implements Comparable {
 
    private int title;
     
    public Teacher(int title) {
        super();
        this.title = title;
    }
 
    public int getTitle() {
        return title;
    }
 
    public void setTitle(int title) {
        this.title = title;
    }
 
    @Override
    public int compareTo(Teacher o) {
        if(this.title > o.getTitle()){
            return 1;
        }else if(this.title == o.getTitle()){
            return 0;
        }else{
            return -1;
        }
    }
     
    @Override
    public String toString() {
        return "teacher--" +title+" ";
    }
}

5. 定义测试类

public class Test {

    public static void main(String[] args) {
        Student[] students = {new Student(10),new Student(5),new Student(100)};
        DataSorter.sort(students);
        DataSorter.show(students);
        System.out.println("----------------------");
        Teacher [] ts = {new Teacher(10),new Teacher(3),new Teacher(12)};
        DataSorter.sort(ts);
        DataSorter.show(ts);
    }
}

6.输出结果

student5 
student10 
student100 
----------------------
teacher--3 
teacher--10 
teacher--12