3分钟带你快速了解 Java 接口

我醉欲眠卿且去

明朝有意抱琴来

目录

接口的概念

定义接口

接口格式

接口的特性

（1）接口不能直接创建对象

（2）接口不能用 final 修饰

（3）接口中定义的变量

（4）接口中定义的方法

接口的作用

抽象类与接口

抽象类

接口

接口的概念

在我们现实生活中接口的例子十分的常见。比如：USB接口、插座接口等等

电脑的USB口上，可以插：U盘、鼠标、键盘等等所有符合USB协议的设备

电源插座插孔上，可以插：电脑、电视机、电饭煲等等所有符合规范的设备

通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型

定义接口

接口格式

定义一个接口跟定义一个类的格式差不多，只不过是将 class 关键字换成 interface 关键字

[public] interface <接口名> {
    //常量
    //抽象方法、静态方法、默认方法
}

public	接口的修饰符只能是 public ，只有这样接口才能被任何包中的接口或者类访问
interface	接口的关键字
接口名	定义方式跟类名一样
常量	在接口中不能声明变量，因为接口要具备三个特征，公共性、静态的、最终的

接口的特性

我们一旦在 Java 程序中创建了接口后，接口的方法和抽象类是一样的，它的方法都是抽象的，也就是说接口不具备有实现的功能（不能被创建对象）它只是指定要做那些工作，而不管怎么去做。接口就如用户提出的需求，最后由你去扩展它的实现类

（1）接口不能直接创建对象

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

（2）接口不能用 final 修饰

因为接口就是为了让子类实现的，如果将接口封闭了，那么接口将没有任何意义

（3）接口中定义的变量

我们现在接口中定义一个变量，我们发现编译器会提示我们进行初始化

当我们初始化后就正常了，这是什么回事呢？

看一下这段代码反编译后的字节码，如下图：

我们发现接口中定义的变量会在编译的时候自动加上 public static final 修饰符，这样我们在接口中便只能定义常量了 ~

（4）接口中定义的方法

接口中可以定义抽象方法、静态方法、默认方法（我们这里主要讲抽象方法）

public interface newJie {
    int a = 10;
    static void Func1(){
        System.out.println("这是一个静态方法");
    }
    
    void Func2();

    default void Func3() {
        System.out.println("这是一个默认方法");
    }
}

普通方法会默认转化成抽象方法：如下图我们给 Func2 加上方法体就报错了

在 Java 程序中，接口里的方法都是抽象的或者是公有的，在声明的时候可以省略掉关键字 public 和 abstract，因为它的方法都是编译器隐式加上的（与上文的接口中的变量一样）。当然我们添加了关键字也没有事 ~

接口的作用

接口不能直接使用，必须要有一个 "实现类" 来 "实现" 该接口，实现接口中的所有抽象方法

接口的格式

public  class 类名称 implements 接口名称{
 // ...
 }

子类和父类之间是 extends 继承关系，类与接口之间是 implements 实现关系

interface Person{
    void eat();
}

class Student implements Person{
    public void eat(){
        System.out.println("吃学生餐");
    }
}

一个接口继承多个接口

在 Java 程序中，接口的继承与类的继承不一样。接口是支持多继承的，即一个接口可以有多个父类接口，与类的继承相似，子类接口要扩展某个父类接口，将会获得父类接口中的所有抽象方法、常量属性、等等。但一个接口继承多个父接口时，多个父接口排在 extendds 关键字之后，多个父接口之间以英文符号 “，” 隔开

interface A{
    int add();
}

interface B{
    int sub();
}

interface C{
    int mul();
}

interface D extends A,B,C{}

class E implements D{
    private int a;
    private int b;

    public E(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public int add(){
        return a+b;
    }

    public int sub(){
        return a-b;
    }

    public int mul(){
        return a*b;
    }
}

public class Test {
    public static void main(String[] args) {
        E e = new E(3,4);
        System.out.println("add="+e.add());
        System.out.println("sub="+e.sub());
        System.out.println("mul="+e.mul());
    }
}

我们发现接口D 中继承了接口A、B、C 中所有的抽象方法，因为 E类继承了接口D 能实现所有的抽象方法

一个类继承多个接口

我们在继承中讲过，Java 是不支持多继承的：

错误示范

class A{
    protected int a;
}

class B{
    protected int b;
}

class C extends A,B{}

虽然 Java 中不能实现类继承多个类，但是可以一个类继承多个接口：

public interface Father {
    void Character();
}
---------------------------------------
public interface Mother {
    void Appearance();
}
---------------------------------------
class Child1 implements Father,Mother{
    protected String Name;
    protected int Age;
    @Override
    public void Character(){
        System.out.println("勇气");
    }
    @Override
    public void Appearance(){
        System.out.println("蓝眼睛");
    }

    public Child1(String name, int age) {
        Name = name;
        Age = age;
    }

    public void PrintChild() {
        System.out.println("姓名："+this.Name+" 年龄："+this.Age);
    }
}

class Child2 extends Child1{
    public Child2(String name, int age) {
        super(name, age);
    }
    @Override
    public void Character(){
        System.out.println("帅气");
    }
    @Override
    public void Appearance(){
        System.out.println("勤快");
    }
}
---------------------------------------
public class Test {
    public static  void Character(Child1 d){
        d.Character();
    }
    public static void Appearance(Child1 d){
        d.Appearance();
    }


    public static void main(String[] args) {
        Child1 child1 = new Child1("张三",18);
        child1.PrintChild();
        System.out.println("特征：");
        child1.Appearance();
        child1.Character();
        System.out.println("---------------------------------");
        Child2 child2 = new Child2("小美",19);
        child2.PrintChild();
        System.out.println("特征：");
        child2.Appearance();
        child2.Character();
    }
}

代码虽然有点长，我们来慢慢分析一下

问题：如何描述两个孩子的不太特征？

首先一个孩子的特性可以与父母有关：

于是我们可以定义了两个接口：Father、Mother

我们由第一个孩子 Child1 继承这两个接口，并实现接口中的抽象类

这个时候第二个孩子 Child2 就不用继承这两个接口了，我们直接继承 Child1 并重写接口方法

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类

错误示范：

interface A{
    void Func1();
    void Func2();
}

class B implements A{
    public void Func1(){
        System.out.println("B");
    }
}

如果你此时不想实现，你可以将该类定义为抽象类，从而来避免这个错误

一个类只能继承一个类，但是一个类可以继承多个接口。这在编写程序时解决了一个类要具备多方面的特征 ~

抽象类与接口

抽象类

通过关键字 abstract 定义的类叫做抽象类。在 Java 中所有的对象都是通过类来描述的；但反过来，并不是所有的类都是用来描述对象的，抽象类就是其中的一种

这里展示一下什么叫抽象类：

abstract class C{
    abstract void Func();
    public void Func1(){
        System.out.println("C");
    }
}

我们知道抽象类是至少有一个抽象方法的类叫做抽象类，这也意味着抽象类中存在不是抽象方法的方法。这样抽象类就不能算作是纯粹的接口，而是介于普通类与接口之间。

接口

是一个抽象类型，是抽象方法的集合；接口通过关键字 interface 来定义。接口与抽象类的不同之处在于：

接口中的成员变量隐式为 static final，但抽象类不是的

一个类可以实现多个接口，但只能继承一个抽象类

抽象类中可以存在有方法的方法，而接口中（除了静态方法、默认方法这些特殊方法）就只有抽象方法

接口是隐式抽象的，所以声明时没有必要使用 abstract 关键字

接口中的方法都是隐式 public 的