目录

❤️❤️❤️接口的概念

❤️❤️❤️抽象类 和 接口 的区别

❤️❤️❤️接口的其他特性：

❤️❤️❤️接口的格式

❤️❤️❤️接口的使用

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

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

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

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

️️️输出结果：

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

️️️注意事项

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

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

 ️️️输出结果

接口的概念

接口我们可以理解为比 抽象类 更抽象的类，但接口又不是类，也可看做特殊功能的类，因为即使关键字是 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());
    }

 输出结果

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