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 的