JAVA-SE-接口2

一，接口之间的继承

接口与接口之间的继承使用 extends 关键字，并且一个接口可以继承多个接口，例如：

interface A{
    void eat();
}
interface B{
    void sleep();
}
interface C extends A,B{
    int a = 10;
}

注意：接口之间的继承可以不重写抽象方法，但实现了接口的类必须重写接口中的抽象方法，例如：

interface A{
    void eat();
}
interface B{
    void sleep();
}
interface C extends A,B{
    int a = 10;
}

public class Test implements C{

    @Override
    public void eat() {
        System.out.println("吃饭！");
    }

    @Override
    public void sleep() {
        System.out.println("睡觉！");
    }
}

二，抽象类和接口的区别

1.抽象类中可以有普通方法也可以有抽象方法，而接口中方法默认是由public abstract修饰的

2.抽象类中可以有普通类成员，而接口中的成员变量默认是public static final修饰的

3.一个类只可以继承一个抽象类，却可以实现多个接口

4.接口也可以继承多个接口

三，接口使用实例

 比较大小-------对象数组排序

在JAVA中我们可以通过Array.sort()来实现数组的排序，例如：

public class Test1 {
    public static void main(String[] args) {
        int[] a = new int[]{9,3,2,1,5,4,7,0};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

 那么当我们刚才的整形数组变成对象数组时，我们是否还能直接通过Arrays.sort()来实现排序呢？

import java.util.Arrays;

class Person{
    public String name;
    public int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}

public class Test2 {
    public static void main(String[] args) {
        Person[] people = new Person[3];
        people[0] = new Person("zhangsan",10);
        people[1] = new Person("lisi",5);
        people[2] = new Person("wangwu",9);
        Arrays.sort(people);
        System.out.println(Arrays.toString(people));
    }
}

  

答案是否定的，因为此时的情况比较复杂，我们定义的Person类有两个成员变量(name和age)，也就是说，我们可以按照name来排序，也可以按照age来排序，在这种情况下，我们需要规定按照什么来比较大小，这个时候我们就要使用Comparable接口并重写其中的compareTo方法，例如：

import java.util.Arrays;

class Person implements Comparable<Person>{
    public String name;
    public int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "[" + this.name + "," + this.age + "]";
    }

    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
}

public class Test2 {
    public static void main(String[] args) {
        Person[] people = new Person[3];
        people[0] = new Person("zhangsan",10);
        people[1] = new Person("lisi",5);
        people[2] = new Person("wangwu",9);
        System.out.println("排序前："+Arrays.toString(people));
        Arrays.sort(people);
        System.out.println("排序后："+Arrays.toString(people));
    }
}

总结：在比较一个复杂对象时，需要一个标准(按照什么比较)，因此在JAVA中我们需要实现Comparable接口并且重写compareTo方法，因为Arrays.sort()方法会调用comparaTo方法，并以此来排序，在C语言中也有类似的函数，例如qsort函数，需要我们提供一个比较函数。我们可以将两者联系起来，方便理解。

下面我们使用冒泡排序来实现一下sort方法(Person类与上面的一致)：

public class Test2 {
    public static void bubble(Comparable[] comparable){
        for (int i = 0; i < comparable.length - 1; i++) {
            for (int j = 0; j < comparable.length - 1 - i; j++) {
                if(comparable[j].compareTo(comparable[j+1]) > 0){
                    Comparable tmp = comparable[j];
                    comparable[j] = comparable[j+1];
                    comparable[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Person[] people = new Person[3];
        people[0] = new Person("zhangsan",10);
        people[1] = new Person("lisi",5);
        people[2] = new Person("wangwu",9);
        System.out.println("排序前："+Arrays.toString(people));
        bubble(people);
        System.out.println("排序后："+Arrays.toString(people));
    }
}

接下来介绍另外一种比较大小的方式--------Comparator接口

//通过名字比较
class NameComparator implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Person people1 = new Person("zhangsan",10);
        Person people2 = new Person("lisi",5);
        NameComparator nameComparator = new NameComparator();
        System.out.println(nameComparator.compare(people1,people2));
    }
}