＜＜Java＞＞ 接口

接口的概念

接口我们可以理解为比 抽象类 更抽象的类，但接口又不是类，也可看做特殊功能的类，因为即使关键字是 inteface 编译后文件还是 xxxx.class

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

抽象类 和 接口 的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口的其他特性：

1. 接口是一种引用类型 但不能直接new接口的对象

2. 接口中每一个方法都是public的抽象方法，方法会被隐式的指定为 public abstract（且只 能是 public abstract，其他修饰符都会报错）。

3. 接口可以有成员变量，但会被隐式的指定为 public stastic final 变量（且只能如此）

4. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

5. 如果类中没有实现接口中的全部功能，则类必须设置为抽象类

接口的格式

public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

接口的使用

class 类 implements 接口1 , 接口2 {
    重写接口中方法
}

案例①

接口的使用案例----------compareTo

代码 ----- 我们写一个学生类，使用 Comparable 这个接口

    public static class Student implements Comparable{
        String name;//成员变量
        int age;//成员变量
        int score;//成员变量

        public Student(String name, int age, int score) {
            this.name = name;
            this.age = age;
            this.score = score;
        }

        @Override//重写conpareTo这个方法，用来比较分数
        public int compareTo(Object o) {
            Student student = (Student) o;
            return this.score - ((Student) o).score;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", score=" + score +
                    '}';
        }
    }

代码 ------ 创建一个main类 执行compareTo这个方****法

public static void main(String[] args) {
        Student student1 = new Student("xiaowang",16,66);
        Student student2 = new Student("xiaowang",16,99);
        Student student3 = new Student("xiaowang",16,20);
        //使用重写的方法， 比较student1 和student2 的成绩
        int flag = student1.compareTo(student2);
        System.out.println(flag);
    }

输出结果：student1 的成绩 < student2 的成绩

代码 ----- 创建一个Student数组 , 通过Array.sort 进行排序

    public static void main(String[] args) {
        Student[] student = new Student[3];
        student[0] = new Student("xiaowang",16,66);
        student[1] = new Student("xiaowang",16,99);
        student[2] = new Student("xiaowang",16,20);

        System.out.println("排序前");
        System.out.println(student[0].toString());
        System.out.println(student[1].toString());
        System.out.println(student[2].toString());
        
        Arrays.sort(student);//通过sort方法进行排序
        
        System.out.println("排序后");
        System.out.println(student[0].toString());
        System.out.println(student[1].toString());
        System.out.println(student[2].toString());
    }

输出结果：

** 通过结果我们可以发现 ， 直接就进行了排序 我们不需要再写排序的函数 那是因为 Array这个类的内部含有这个方法 ，而这个方法的比较方法就是调用的compareTo这个方法，所以我们通过重写conpareTo这个方法 ， 就可以按照我们想要的方式进行排序！**

案例②

接口的使用案例----------Copy

protected Object clone ( ) throws CloneNotSupportedException

注意事项

1. clone的使用需要重写：

原因：protected 修饰 ------ 不在同一个包的子类不能直接调用，必须通过super

由于 Object 本身没有实现 Cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常。

2. 克隆的类要继承Cloneable这个接口

原因：这个接口是一个空接口（又叫标记接口），而要使一个类实现克隆，必须有这个接口。

代码 ------ 写一个 Student 类

    public static class Student implements Cloneable{//Cloneable是空接口(标记接口)，里面没有内容，代表实现了这个接口的类可以被克隆
        //因此，我们要一个类实现克隆，必须继承这个接口
        String name;//成员变量
        int age;//成员变量
        int score;//成员变量
        public Student(String name, int age, int score) {
            this.name = name;
            this.age = age;
            this.score = score;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", score=" + score +
                    '}';
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

代码 ------ main函数实现克隆

    public static void main(String[] args) throws CloneNotSupportedException{
        Student student1 = new Student("张三",20,31);
        Student student2 = (Student)student1.clone();
        System.out.println(student1.toString());
        System.out.println(student2.toString());
    }

输出结果

** 我们可以看到克隆的使用条件比较多，所有写克隆的时候一定要注意！**