接口（非完整版，代更）

接口是啥？

接口是公共标准的行为规范。
比如：电脑中的USB接口，可以插鼠标，键盘，U盘等等满足USB协议的东西。
那在Java中接口是多个类的公共规范。

首先，接口不是类。但它又和类有诸多相似之处，所以这里注重说明其与类的差异。
接口是一种引用数据类型。
接口作为一个强大的高级技术，接着完善你的工具箱，在实践中体会其奥妙吧。

接口的知识点阐述

以下内容

1. 根据实际遇到的困难进行复习达到通透的目的.也可初步学习
   一些总结，熟练应用才是王道

1. 接口允许存在成员变量，但这个变量默认为 public static final .
   没错连着三个关键字修饰。

public interface Example {
    int a=0;//等价于public static final a=0;
    public static int b=0;//这样写可，但是Java代码规范中建议像上面写，那样更简洁。
}

• 这里的变量a由于被final修饰，说明它是常量，更严格来说，接口不能接受实例字段只能接受常量。

2. 成员方法默认为public abstract.接口中的每一个方法都是公共抽象的，当然会说明特例。但是请记住贸然添加private及其它修饰符会报错。

public interface Example{
     void method1();//默认为public abstract，抽象方法不需要具体实现。
    public abstract void method2();//由于代码规范，多余关键字可以不用写出。
}

接口中的方法默认为抽象方法，不能由自己实现，而是由实现该接口的类来重写这个方法。
下面来说明两个特例：
在接口中，static 关键字修饰的方法可以具体实现。
java8中明确指出可以在接口中加入静态方法，虽然违背其作为接口的初衷（只作为部分类的公共规范）。

public interface Example{
    static void method3(){
        System.out.println("我是一个静态方法，我可以在接口中实现");
    }
}

另一个特例：
默认方法，用default修饰符标记一个方法就可以具体实现。

public interface Example { 
    default void method4(){
    System.out.println("我是一个default修饰的方法，我可以在接口中具体实现");
    }
}

目前以我的学习，我还并没有用上这个默认方法。

3. 接口被实现后，类中对应重写接口的方法必须用public修饰，因为子类重写方法，权限必须大于等于父类（接口），接口中的方法被public修饰（这里指一般情况），所以子类方法必须加上public。

4. 接口不是类，不能实例化对象。

public class Main {
    Example example = new Example() ;//报错，不能new来实现一个接口“对象”。
}

5. 类与另一个类是继承关系，类与接口是实现关系。

类可以extends来继承一个类（字段，方法）；
类可以implements来实现接口中的方法。

6. 接口引用变量可以引用子类（implements 该接口）的对象。

public class Main implements Example{
    @Override
    public void method1(){
        System.out.println("我要重写父类接口的方法");
    }
    @Override
     public void method2(){
        System.out.println("我要重写完接口的抽象方法！！！");
    }
    Main mian = new Main();
    Example pmian = mian;//接口的引用变量引用了子类的对象！！！
    
}

7. 每个接口和类一样都对应各自一个字节码文件(.class)

8. 接口与接口之间允许继承，即接口与接口之间可以通过extends关键字扩展。

接口语法（Comparable接口介绍）

我们以Comparable接口为例来介绍一下其语法。

public interface Comparable{
    int comparaTo(Object other);
}

• 这个接口只提供了一种方法，comparaTo.前面总结过，它是一个public abstract的方法，意味着所有implements Comparable的类都要具体实现该方法。
• comparaTo方法里的参数Object类型，它接受所有类的对象为参数，并返回一个整型。
  定义一个接口要用interface关键字，接口名的命名规范和类一致，采用大驼峰命名

接口命名最好还需遵守：

1. 从阅读角度，接口名以I开头方便区分这是一个接口而不是类。
2. 接口名最好是“形容词”。
3. 根据阿里编程规范，不要在接口内常量方法加入多余关键字修饰。

Comparable接口使用

• 下面我们通过Student类来举例说明。
• 我们试图创建一个Student类的数组，并通过Array类的sort，toString方法来排序打印一下.

下面是例子(试运行一下)：

import java.util.Arrays;

public class Student {
    private String name = null;
    private int score = 0;

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

    @Override
    public String toString() {
        return "[" + name + ":" + score + "]";
    }

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 95),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

• 非常遗憾报错了，对于一般的对象我们要自行实现comparaTo方法。
• 言下之意，Students类必须要自己实现Comparable接口。
• 这么一想，确实这个理。当前这个自定义类要根据那个规则进行比较呢？这个规则怎么定义？

import java.util.Arrays;

public class Student implements Comparable{
    private String name = null;
    private int score = 0;

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

    @Override
    public String toString() {
        return "[" + name + ":" + score + "]";
    }

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 95),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

    @Override
    public int compareTo(Object o) {
        //这里根据分数比较。
        return this.score-((Student)o).score;
    }
}

Comparable泛型接口？

Java5以后，Comparable接口以及升级成一个泛型了。
那什么是泛型呢？我们这里简单说一下。否则要另起一篇文章巴拉巴拉谈接口了。

顾名思义，泛型（广泛的类型），意思是数据类型可以作为参数使用了。（^~）C语言出身直接落泪。(类型终于可以当参数传来)
请看的Comparable船新定义。

public interface Comparable<T>
{
    int compareTo(T other);//从超类Object过渡具体的类了。
}

• 有啥用？看看上面的compatrTo实现用了向下转型，可以不用类型转换了！！

public class Student implements Comparable<Student>//类的定义改成这一句。

 @Override
    public int compareTo(Student o) {
        return this.score-o.score;//Object被替换成Student了
    }

单小结进行一个汇总One

1. 提问One:Comparable与Comparable这两种接口写法那种正确？

答案肯定无疑都正确，泛型在Java5后引入为了兼容过去的版本，允许最初不带泛型的写法。不用泛型默认参数为Object需要使用强制类型转换来向下转型。

2. 提问Two：Arrays.sort(参数)，这个参数以前在排整型数组时我们没实现过啊？

java.util.Arrays中的sort方法static void sort(Object[] a),指出参数中数组元素对应的类必须实现Comparable接口。
而对于基本数据类型int的数组，java.util.Arrays中的sort方法重载，可以接受基本数据类型为元素的数组，它们在底层上实现了Comparator接口。

3. 提问Three:为什么我们不单独实现compareTo方法，而必须通过实现Comparable接口的方式来定义compareTo方法呢？

Java是一种强类型语言，它很严格，调用方法前，它要检查这个方法确实存在。而实现这个接口就意味对应的类必须提供这个方法的具体定义。

总结：对与一般类的数组，若调用Arrays类的sort方法，sort内部会调用这个类的compareTo方法，来确保这些个数组对象是可以比较的（按什么逻辑比较），所以这个类必须实现Comparable接口，而compareTo方法内部的比较逻辑取决于我们。

关于一些补充接口与类的差异

1. 类有字段，接口也允许字段。只不过接口字段是public static final.
   这意味着接口字段（final）必须在定义时就初始化值。（static）意味着该字段在方法区的常量池中。编译期已被决定。
   字段访问方式:接口名. 或者实现接口的类，及其对象，引用，来访问。
2. 接口允许三种方法public static 方法（不加任何关键字的写法）；默认方法；静态方法；
3. 类中允许有静态代码块，接口不允许。
4. 类中有构造器（自己没写编译器会默认给一个），接口中没有构造器且自己不能实现一个构造器。

抽象类与接口

在Java中类只能继承一个类，任何一个类没明确继承啥父类都会默认继承Object类。
假如Children类继承Parents类，Parents继承Object类。每个类继承关系只能单继承。
Java不支持多继承，但可以实现多个接口。

public class Children extends Parents implements Comparable，SwingConstants{
    //…………
}

//代更。个人笔记不定期更新—Java合集