面向对象编程-12-接口使用实例

接口使用实例

再来定义一个学生类来理解一下

 package packageStudent;

public class Student {
    private String name;
    private int score;
    //构造方法
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    //重写方法
    @Override
    public String toString() {
        return "["+this.name+":"+this.score+"]";
    }
}

再给定一个学生对象数组，对这个对象数组中的元素进行排序（按分数降序）

public class Test {
    public static void main(String[] args) {
        Student [] students=new Student[]{
                new Student("张三",99),
                new Student("李四",79),
                new Student("王五",109), 
                new Student("赵六",88),
        };
    }
}
 

按照之前的理解，数组我们有一个现成的sort方法，

public class Test {
    public static void main(String[] args) {
        Student [] students=new Student[]{
                new Student("张三",99),
                new Student("李四",88),
                new Student("王五",77),
                new Student("赵六",76),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}
//运行结果：
抛出异常
Exception in thread "main" java.lang.ClassCastException: packageStudent.Student cannot be cast to java.lang.Comparable
	at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
	at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
	at java.util.Arrays.sort(Arrays.java:1246)
	at packageStudent.Test.main(Test.java:13)

原因是：
两个整数是可以比较大小的，但是两个学生对象不能比较大小。
但是这两个学生的大小关系，可以额外指定

让 Student类实现Comparable接口，并实现其中的compareTo方法

public class Student implements Comparable{
    private String name;
    private int score;
    //构造方法
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    //重写方法
    @Override
    public String toString() {
        return "["+this.name+":"+this.score+"]";
    }
    //重写方法
    @Override
    public int compareTo(Object o) {
        Student s = (Student) o;
        if (this.score > s.score) {
            return -1;
        } else if (this.score < s.score) {
            return 1;
        } else {
            return 0;
        }
    }
}

在sort方法中会走动调用compareTo方法，compareTo的参数是Object，其实传入的就是Student类型的对象，然后比较当前对象和参数对象的大小关系（按分数来计算）。
1、如果当前对象应排在参数之前，返回小于0的数字
2、如果当前对象应排在参数之后，返回大于0的数字
3、如果当前对象和参数对象不分先后，返回0；
再次执行程序，结果符合预期

//执行结果：
[[张三:99], [李四:88], [王五:77], [赵六:76]]

Process finished with exit code 0

注意事项：
对于sort方法来说，需要传入的数组的每个对象都是“可比较”的，需要具备compareTo这样的能力，通过重写compareTo方法的方式，就可以定义比较规则。

为了进一步加深对接口的理解，我们可以尝试自己实现一个sort方法来完成刚才的排序过程（使用冒泡排序）

public static void sort(Comparable[] array) { 
    for (int bound = 0; bound < array.length; bound++) {
             for (int cur = array.length - 1; cur > bound; cur--) {
                     if (array[cur - 1].compareTo(array[cur]) > 0) {
                      // 说明顺序不符合要求, 交换两个变量的位置
                     Comparable tmp = array[cur - 1]; 
                      array[cur - 1] = array[cur];
                      array[cur] = tmp;
                       } 
                }
         }
 } 

再次执行代码：

sort(students); 
System.out.println(Arrays.toString(students)); 
 
// 执行结果
 [[王五:97], [李四:96], [张三:95], [赵六:92]]