开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 【Java知识点系列】：接口 -> 正文阅读

[Java知识库]【Java知识点系列】：接口

🍀为什么有接口

请大家先看一张图:
在这里插入图片描述

USB插槽就是现实中的接口。
你可以把手机,相机,u盘都插在USB插槽上,而不用担心那个插槽是专门插哪个的,原因是做usb插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸,排线等等。

🍀接口快速入门

这样的设计需求在java编程/php/.net/go中也是会大量存在的,一个程序就是一个世界,在现实世界存在的情况，在程序中也会出现。我们用程序来模拟一下。

🔌设计一个接口UsbInterface

package com.hj.第十章面向对象编程下.接口;

/**
 * @author Baridhu
 */
public interface UsbInterface { //接口
    //规定接口的相关方法,老师规定的.即规范...
    public void start();
    public void stop();
}

📷Camera 实现 UsbInterface

public class Camera implements UsbInterface{//实现接口,就是把接口方法实现
    @Override
    public void start() {
        System.out.println("相机开始工作...");
    }
    @Override
    public void stop() {
        System.out.println("相机停止工作....");
    }
}

📱Phone实现 UsbInterface

//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始工作...");
    }
    @Override
    public void stop() {
        System.out.println("手机停止工作.....");
    }
}

💻Computer 类：

package com.hj.第十章面向对象编程下.接口;

/**
 * @author Baridhu
 */
public class Computer {
    //编写一个方法，计算机工作
    public void work(UsbInterface Usb) {
        //通过接口，来调用方法
        Usb.start();
        Usb.stop();
    }

}

🍀基本介绍

? 接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。

📙语法:

interface接口名{
	属性
	抽象方法
}
class 类名 implements 接口{
	自己属性;
	自己方法;
	必须实现的接口的抽象方法
}

💡小结:

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。

🔥特别说明:

Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

🍀深入讨论

对初学者讲.理解接口的概念不算太难,难的是不知道什么时候使用接口,下面我例举几个应用场景:

说现在要制造战斗机,武装直升机.专家只需把飞机需要的功能/规格定下来即可,然后让别的人具体实现就可。
现在有一个项目经理,管理三个程序员,功能开发一个软件,为了控制和管理软件,项目经理可以定义一些接口，然后由程序员具体实现。(1.项目质量2.项目进度3.项目奖)参加工作

👍举例实现：
DBInterface接口

package com.hj.第十章面向对象编程下.接口.简单案例;

/**
 * @author Baridhu
 */
public interface DBInterface { //项目经理
    public void connect();//连接方法
    public void close();//关闭连接
}

MysqlDB实现DBInterface

package com.hj.第十章面向对象编程下.接口.简单案例;

/**
 * @author Baridhu
 */
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接 mysql");
    }
    @Override
    public void close() {
        System.out.println("关闭 mysql");
    }
}

OracleDB 实现 DBInterface

//B 程序员连接 Oracle
public class OracleDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接 oracle");
    }
    @Override
    public void close() {
        System.out.println("关闭 oracle");
    }
}

实现类：

public class Interface03 {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}

🍀注意事项和细节

接口不能被实例化
接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
图示:
一个普通类实现接口，就必须将该接口的所有方法都实现。
抽象类实现接口，可以不用实现接口的方法。

//4.抽象类去实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();//修饰符 public protected 默认 private
    void hi();
}
abstract class Tiger implements IA {
}

一个类同时可以实现多个接口

interface IB {
    //接口中的属性,只能是 final 的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    void say();
}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override
    public void hi() {
    }
    @Override
    public void say() {
    }
}

接口中的属性,只能是final的，而且是 public static final修饰符。比如:int a=1;实际上是 public static final int a=1;(必须初始化)

interface IB {
    //接口中的属性,只能是 final 的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}

接口中属性的访问形式:接口名.属性名

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //接口中的属性,是 public static final
        System.out.println(IB.n1);//说明 n1 就是 static
        //IB.n1 = 30; 说明 n1 是 final
    }
}
interface IB {
    //接口中的属性,只能是 final 的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}

接口不能继承其它的类,但是可以继承多个别的接口

interface A extends B,C{}

接口的修饰符只能是public和默认，这点和类的修饰符是一样的。

public interface UsbInterface{}
interface IE{}

🍀课堂练习

T1:判断下面代码输出

public interface A{
    int a=23;
}
class B implements A{}
public class C {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.a);
        System.out.println(A.a);
        System.out.println(B.a);

    }
}

答案：
在这里插入图片描述

🍀继承类和接口的区别

大家看到现在,可能会对实现接口和继承类比较迷茫了,网上也有很多帖子在讨论这个问题,那么他们究竟有什么区别呢?

🚀比如说我们现在有一个小猴，它是继承自上面的老猴的(红色箭头)，但是它想要学会飞行和游泳，这时它就需要像小鸟和小鱼去学习怎样去飞行和游泳，这是我们所说的实现，学习就是去实现(灰色箭头)。

💡代码实现：

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}
//猴子
class Monkey {
    private String name;
    public Monkey(String name) {
        this.name = name;
    }
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }
    public String getName() {
        return name;
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
    //继承
//小结: 当子类继承了父类，就自动的拥有父类的功能
// 如果子类需要扩展功能，可以通过实现接口的方式扩展. 
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.

class LittleMonkey extends Monkey implements Fishable,Birdable {
    public LittleMonkey(String name) {
        super(name);
    }
    @Override
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }
    @Override
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

💡再次说明：
?接口和继承解决的问题不同

继承的价值主要在于:解决代码的复用性和可维护性。
接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活

?接口比继承更加灵活

接口比继承更加灵活，继承是满足is - a的关系(什么是一个什么)，而接口只需满足 like - a(什么像一个什么)的关系。

?接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]

🍀接口的多态特性

?多态参数(前面案例体现)
在前面的Usb接口案例，UsbInterface usb，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        //继承体现的多态
        //父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {
}
class BBB extends AAA {}
class CCC extends AAA {}

?多态数组
演示一个案例:
给Usb数组中，存放 Phone 和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，还需要调用Phone特有方法call.

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给 Usb 数组中，存放 Phone 和 相机对象，Phone 类还有一个特有的方法 call（），
        请遍历 Usb 数组，如果是 Phone 对象，除了调用 Usb 接口定义的方法外，
        还需要调用 Phone 特有方法 call
        */
        for(int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定.. //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}
interface Usb{
    void work();
}
class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }
    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

? 接口存在多态传递现象

/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
        //那么，实际上就相当于 Teacher 类也实现了 IH 接口. //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}
interface IH {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}