一、概述

1.介绍 :

2.定义 :

二、特点

1.接口成员变量的特点 :

2.接口成员方法的特点 :

3.接口构造方法的特点 :

4.接口创建对象的特点 :

5.接口继承关系的特点 :

三、应用 :

1.情景 :

2.多态 :

①多态的传递性 :

②关于接口的多态参数和多态数组 :

四、总结 :

一、概述

1.介绍 :

接口技术用于描述类具有什么功能，但并不给出具体实现，当某个类要使用接口时，再去实现接口中的这些方法。类需要遵从接口中描述的统一规则进行定义，所以，接口是对外提供的一组规则，标准。

2.定义 :

①定义接口要用到关键字interface，格式如下 :

interface 接口名 {

}

②类和接口之间不再是继承，而是实现关系，用implements关键字表示。如下 :

class 类名 implements 接口名 {

}

Δ需要注意的是：与类的定义类似，接口的访问权限修饰符只能是public或者默认。

IDEA中定义接口的步骤如下 :

1>先像平时创建类一样正常点击New——>Java Class；如下图所示 :

2>然后在弹出的窗口中选择Interface，输入接口名，回车即可。如下图所示 :

二、特点

1.接口成员变量的特点 :

Δ接口中没有成员变量，只有公有静态常量。

即默认情况下属性前都会有public static final 这三个关键字修饰。如下 :

public static final 数据类型 常量名 = 常量值;

Δ还记得我们在final关键字详解中讲到的——关于final修饰属性的初始化问题吗？

当时，我们说，final修饰的属性必须进行初始化，而对于公有静态常量，初始化的途径只有两条——①定义时②静态代码块中。但是很遗憾，接口中不允许存在代码块，而且接口没有构造方法。因此，这就要求我们在接口中定义公有静态常量时，必须在定义时就赋初值。否则IDEA报错。

演示 :

我们以DemoInterface接口为演示接口，在该接口中定义i变量，并定义Test类作为测试类，如下所示 :

可以看到，IDEA对于i变量前的三个关键字均作了灰色处理，表明这三个修饰符是默认的，你写不写它都在！在测试类中，我们尝试更改i变量的值，IDEA会马上报错，如下图所示 :

而可通过接口名来调用i变量也体现出static关键字的存在。

2.接口成员方法的特点 :

①在JDK7.0版本之前，接口中仅支持公有的抽象方法：

public abstract 返回值类型方法名();

Δ事实上，接口中的方法默认就是公有抽象方法，因此在接口中定义抽象方法时，可以省略掉abstract关键字。

②从JDK8.0开始，接口中可以由默认方法和静态方法：

默认方法——public default 返回值类型方法名() {

}

静态方法——public static 返回值类型方法名() {

}

Δ需要注意的是，想定义默认方法必须在前面添加default关键字，因为接口中的方法如果你什么都不写，默认是公有的抽象的方法。默认方法可以有方法体，且不需要实现类去实现，其实就是我们平时见到的普通的成员方法。但是默认方法是可以被实现类重写的。default关键字只能在接口中使用。就算实现类要重写默认方法，实现类中重写后的方法也不能添加default修饰符，不然IDEA报错。

③JDK9.0以后，接口中可以有私有方法 :

private 返回值类型方法名() {

}

演示 :

我们以Demo2接口为演示接口，以Imple类作为Demo2接口的实现类，最后以Test2类作为测试类，代码如下 :

package knowledge.port.characters.methods;

public interface Demo2 {
    //①在JDK7.0版本之前，接口中仅支持公有的抽象方法：
    public abstract void hello_world();

    //②从JDK8.0开始，接口中可以由默认方法和静态方法：
        //默认方法
        public default void what_time() {
            System.out.println("姥姥——姥姥——几点啦？");
        }
        //静态方法
        public static double Sum(double x, double y) {
            return x + y;
        }

    //③JDK9.0以后，接口中可以有私有方法 ：
    private void own() {
        System.out.println("这是👴的私有方法。");
    }
    public default void invoke_own() {
        this.own();
    }
}

class Imple implements Demo2{
    @Override
    public void hello_world() {
        System.out.println("你好，世界！");
    }
}

class Test2 {
    public static void main(String[] args) {
        Demo2 d2 = new Imple();
        d2.hello_world();
        System.out.println("---------------------------------");
        d2.what_time();
        System.out.println("传入的x与y的和 = " + Demo2.Sum(141, 135));
        System.out.println("---------------------------------");
        d2.invoke_own();
    }
}

运行结果 :

注意看我们在Demo2接口中定义的第一个抽象的方法，在IDEA中，它是下面这样子的 :

public 和 abstract修饰符均为灰色，再一次说明接口中的方法默认情况为公有的抽象方法。如果想使用默认方法，一定不要忘记添加default关键字。

3.接口构造方法的特点 :

接口存在的目的是为了规范类，因此接口也不可以被实例化。接口中不允许存在代码块，也没有需要初始化的成员，因此接口没有构造方法（构造器）。在接口中定义构造器IDEA会直接报错，如下图所示：

4.接口创建对象的特点 :

①接口不能被实例化 :

只能通过多态的方式实例化“子类”对象（这里的“子类”指的是接口的实现类）

②接口的子类（实现类) :

可以是抽象类，也可以是普通类。
对于抽象实现类，可以不用实现接口的所有方法，因为抽象类本身容许存在抽象方法，语法上是通过的。

对于普通实现类，要求实现接口的所有方法。

演示 :

我们以Demo3接口为演示接口，在接口中定义三个抽象方法greet(), exercise(), study()；以Imple1类和Imple2类作为Demo2接口的实现类，令Imple1类为抽象类，不实现Demo3接口中的抽象方法；令Imple2类为非抽象类，实现Demo3接口中的所有抽象方法。最后以Test3类作为测试类，代码如下 :

package knowledge.port.object;

public interface Demo3 {
    public abstract void greet();
    public abstract void exercise();
    void study();   //默认隐含public abstract修饰符
}

abstract class Imple1 implements Demo3 {
    //实现类Imple1类是抽象类，允许拥有抽象方法，因此可以不实现接口中的方法。
}
class Imple2 implements Demo3 {

    @Override
    public void greet() {
        System.out.println("嗨，你好！");
    }

    @Override
    public void exercise() {
        System.out.println("文明其精神，野蛮其体魄！");
    }

    @Override
    public void study() {
        System.out.println("好好学习，天天向上！");
    }
}

class Test3 {
    public static void main(String[] args) {
        Demo3 d3 = new Imple2();
        d3.greet();
        d3.exercise();
        d3.study();
    }
}

运行结果 :

还记得我们讲过的alt + enter快捷键吗？假如接口中有许多许多许多的抽象方法，如果你要一个一个实现的话麻烦的一批，这时候用我们的快捷键就会方便许多，快捷键演示如下GIF动图：

5.接口继承关系的特点 :

①类和接口之间的关系 :

类与接口是实现关系，支持“多实现”，即一个类可实现多个接口。

②接口与接口之间的关系 :

接口与接口是继承关系，java 支持接口的多继承，即一个接口可以同时继承多个接口，格式如下 :

接口 extends 接口1，接口2，接口3...

③继承和实现的区别：

继承体现的是“is a”的关系，父类中定义共性内容。

实现体现的是“like a”的关系，父接口中定义扩展内容。

PS : 接口的“实现”可以看作是Java中对“单继承机制”的一个补充完善。接口可以在一定程度上实现代码解耦（接口规范性 + 动态绑定）。总的来看，接口比继承更为灵活。

三、应用 :

1.情景 :

实际开发中，为了更好地控制和管理项目，项目经理往往会定义一些接口，具体的实现细节由各位程序🐒实现。🐒儿这时就会根据需求，编写不同的类去实现项目👴给的接口。如下图所示 :

这时候可能就会有p小将（personable小将，指风度翩翩的人）出来问了，直接让🐒儿们去编写类不久完了吗，为啥还得项目👴亲自动手，这不纯纯脱裤子放屁？
p小将您先别急，我给大家举个例子吧——
让三个程序🐒去编写程序，分别建立与Mysql，Oracle，以及DB2数据库的连接，这时，如果项目👴没有定义接口，而是直接让🐒儿编写实现连接的类。三个🐒对于连接的方法可能命名为了三种不同的形式，比方说1号🐒写得connect，2号🐒写得join，3号🐒写得link。如下所示 :

package knowledge.port.application;

public class ToDataBase {
    public static void main(String[] args) {
        SqlConnect mysql = new SqlConnect();
        mysql.connect();

        OracleConnect oracle = new OracleConnect();
        oracle.join();

        DB2Connect db2 = new DB2Connect();
        db2.link();
    }
}
class SqlConnect {
    public void connect() {
        System.out.println("连接到Mysql数据库。");
    }
}
class OracleConnect {
    public void join() {
        System.out.println("连接到Oracle数据库。");
    }
}
class DB2Connect {
    public void link() {
        System.out.println("连接到DB2数据库。");
    }
}

运行结果 :

项目经理如果就这b样儿给上级交上去，要给喷烂😁。
由此，我们看到开发中使用接口的必要性 :

1.无法确定每个程序🐒写得类是否规范，是否符合要求，无法预测最终软件的质量和规范。也无法控制软件最终的功能。
2.接口涉及了统一调用的问题，即接口编程。

解决方案 :

我们可以定义ConnectInterface接口，并在接口中定义抽象方法connect() ，并让🐒儿们去编写类实现这个接口，然后在调用类中利用多态参数，使接口作为形参。

ConnectInterface接口代码如下 :

package knowledge.port.application;

public interface ConnectInterface {    //接口规定了连接方法必须是connect
    public abstract void connect();
}

实现类，调用类代码如下 :

package knowledge.port.application;

public class ToDataBase {
    public static void main(String[] args) {
        SqlConnect mysql = new SqlConnect();
        ToDataBase.connect(mysql);

        OracleConnect oracle = new OracleConnect();
        ToDataBase.connect(oracle);

        DB2Connect db2 = new DB2Connect();
        ToDataBase.connect(db2);
    }
    public static void connect(ConnectInterface connectInterface) {
        connectInterface.connect();
    }
}
class SqlConnect implements ConnectInterface{
    public void connect() {
        System.out.println("连接到Mysql数据库。");
    }
}
class OracleConnect implements ConnectInterface{
    public void connect() {
        System.out.println("连接到Oracle数据库。");
    }
}
class DB2Connect implements ConnectInterface{
    public void connect() {
        System.out.println("连接到DB2数据库。");
    }
}

2.多态 :

在上文中我们提到，接口不能被实例化，而是通过多态的方法实例化子类对象。意思就是说，接口引用指向子类对象也是多态的体现。实际上，接口的多态要从两方面说起。首先我们来说说接口多态的传递性。

①多态的传递性 :

多态的传递性，指的是——如果一个类通过implements关键字实现了某个接口，而这个接口此时又继承了另一个接口，那么就相当了这个类同时实现了这两个接口。而且可以用父接口的引用指向实现类对象。
我们以FatherInterface为父接口，在父接口中定义一个公有抽象方法f()，SonInterface为子接口，Achieve类为子接口的实现类。以Test类为测试类。代码如下 :

package knowledge.port.application.deliver;

public interface FatherInterface {
    public abstract void f();
}
interface SonInterface extends FatherInterface {
    //子接口中啥也没有，但是显然继承了父接口中的公有抽象方法。
}
class Achieve implements SonInterface{
    @Override
    public void f() {
        System.out.println("实现类Achieve实现了子接口中————继承自父接口的抽象方法。");
    }
}
class Test {
    public static void main(String[] args) {
        //可以使用子接口引用指向实现类的多态
        SonInterface sonInterface = new Achieve();
        sonInterface.f();
        //也可以使用父接口引用指向实现类的多态
        FatherInterface fatherInterface = new Achieve();
        fatherInterface.f();
    }
}

运行结果 :

注意，如果此时实现类中没有实现f() 方法，IDEA会报错，如下图所示 :

子接口中没有定义抽象方法，但是子接口继承了父接口，也就拥有了父接口的非私有方法。因此实现类必须实现父接口的抽象方法，而这相当于实现类也实现了父接口，即实现类同时实现了多个接口。

②关于接口的多态参数和多态数组 :

其次，对于我们在多态篇讲到的多态的应用——多态参数和多态数组，接口也同样适用！喏，上面咱们举的项目经理的例子就是接口多态参数的体现。
对于接口的多态参数和多态数组，up将其内容补充在了多态的应用——多态参数和多态数组详解一文中，方便大家对比记忆和理解。博文链接如下： https://blog.csdn.net/TYRA9/article/details/128920758https://blog.csdn.net/TYRA9/article/details/128920758