Java面向对象（高级）-- 接口(interface)

文章目录

一、概念
- （1）引入
- （2）类比
- （3）举例
- - 1. 举例1
  - 2. 举例2
  - 3. 举例3
  - 4. 举例4
- （4）定义格式及重点举例
- - 1. 接口的声明格式
  - 2. 接口的成员说明
  - 3. 接口内部结构的说明
  - 4. 举例
  - - 4.1 举例1--接口
    - 4.2 举例2--类实现接口
    - 4.3 举例3--接口与接口
    - 4.4 举例4--接口与多态性
    - - 4.4.1 案例1--虚方法调用
      - 4.4.2 案例2--创建接口实现类的对象
      - 4.4.3 案例3--创建接口实现类的匿名对象
      - 4.4.4 案例4--创建接口匿名实现类的对象
      - 4.4.5 案例5--创建接口匿名实现类的匿名对象
  - 5 . 总结
二、接口的使用规则
- （1）类实现接口（implements）
- （2）接口的多实现（implements）
- （3）接口的多继承(extends)
- （4）接口与实现类对象构成多态引用
- （5）使用接口的静态成员
- （6）使用接口的非静态方法
三、JDK8与JDK9中接口新特性
- （1）说明
- （2）举例
- - 1. 案例1--JDK8 静态方法
  - 2. 案例2--JDK8 默认方法
  - - 2.1 默认方法
    - 2.2 接口冲突
    - 2.3 类优先原则
    - 2.4 在实现类中调用接口中被重写的方法
  - 3. 案例3--JDK9 定义私有方法
- （3）整体代码
四、JDK8中相关冲突问题
- （1）默认方法冲突问题
- - 1. 类优先原则
  - 2. 接口冲突（左右为难）
- （2）常量冲突问题
五、接口的总结与面试题
- （1）总结
- （2）面试题
六、接口与抽象类之间的对比
七、练习
- （1）练习1
- （2）练习2
- （3）练习3

一、概念

（1）引入

从三条主线的角度来说的话，这儿属于第三条主线，叫做interface关键字的使用。

从另外一个角度来说的话，它是跟类并列的一个结构，这样讲的话，它的地位一下子就提升了。

可以看一下API。

比如说就看一下这个long包下的base。这些结构里边，我们再来看一下这个long包：

可以看到Interface和Class是并列的结构：

平常新建java文件的时候，也可以看到类与接口：

那这个接口到底是一个什么样的结构？跟类并列的是吧？前面我们讲的面向对象特征说类里边都能声明什么，其实都是类的，这个体系跟接口没关系。

（2）类比

生活中大家每天都在用USB接口，那么USB接口与我们今天要学习的接口有什么相同点呢？

USB，（Universal Serial Bus，通用串行总线）是Intel公司开发的总线架构，使得在计算机上添加串行设备（鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等）非常容易。

其实，不管是电脑上的USB插口，还是其他设备上的USB插口都只是遵循了USB规范的一种具体设备而已。

只要设备遵循USB规范的，那么就可以与电脑互联，并正常通信。至于这个设备、电脑是哪个厂家制造的，内部是如何实现的，我们都无需关心。

Java的软件系统会有很多模块组成，那么各个模块之间也应该采用这种面向接口的低耦合，为系统提供更好的可扩展性和可维护性。

接口用interface这个关键字去修饰，就好比类用class来修饰是一样的。首先，要想理解接口，我们先跟生活中的一个例子做一个类比。

生活当中，我们通常提到这个USB，通常就会说USB接口。其实这块呢，就提到了接口这个词，那么这个USB接口跟我们现在讲的这个接口是不是一个概念呢？其实还真可以理解成就是一个概念。

生活当中，大家每天都在用USB接口，首先看USB，它叫通用串行总线。在电脑上，有一个或者有多个USB的接口，我们就可以跟很多外部设备进行连接了。

连接上以后的话，跟电脑就可以进行数据的传输了，这就是我们所谓的USB接口，你会发现全世界的USB接口的标准都是一样的。
比如说里边有几个金属点啊，这个尺寸是什么样子的，全都是一样的，所以我们都可以去做连接。

那么这其实就涉及到了一个USB的规范问题。具体的，不管是英特尔也好，或者它又交给了哪个组织也好，这个组织的话，就来负责制定USB的这个规范。

这个规范呢，咱们作为普通人，能够看到的就是一个长啊宽啊，或者里边有几个金属点（进行数据传输），这都是面儿上能看到的。
那没有看到，其实里边，就会涉及到很多功能的一些规范。

然后要求所有的外部设备，都应该具备相关的一些功能，比如说一连接上电脑以后能够进行，比如电脑对外开放了USB，连接上它以后，首先有提示“可以进行数据传输”了，包括所有的外部设备，我们最后不用的时候，这块儿有对应的弹出。

传输的时候，都会有相应的一些方法的支持。像这些的话，其实都是一些对应的规范，这个规范，在USB这个规范里面，它就定义好了。要求这些外部设备都得去实现。

其实这里边，提到这个USB接口就是我们现在要讲的这样的一种接口的概念，其实是类似的。
那我们这块儿来看一看JAVA当中这个接口是什么意思，回头让大家比对一下，你就知道，其实确实差不多。

（3）举例

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的has-a关系。

1. 举例1

电脑都预留了可以插入USB设备的USB接口，USB接口具备基本的数据传输的开启功能和关闭功能。你能不能用USB进行连接，或是否具备USB通信功能，就看你能否遵循USB接口规范。

比如说图中这个电脑，一个相机、打印机，或者这个U盘，现在想跟电脑进行数据库的传输。

那么，你现在是有没有啊？你要是想进行数据传输了，你能不能有这样的一个规范，这样一个标准呢去遵循呢？如果你遵循了这样的标准了，那我就让你跟电脑进行数据传输；你要没有遵循这个标准，我就不让你进行数据的传输。

所以这个标准的话，就体现为JAVA层面的一个接口，就是可以定义一个接口，假设就叫USB。然后要求、几个设备都得遵循这个规范，这个遵循怎么体现呢？

注意不是继承了，不能说这个打印机的父类是一个USB是吧？那这时候就涉及到类和这个USB接口之间的关系，我们称为实现关系。一旦实现了这个USB接口，它就具备了这个规范里边定义的一些功能。

2. 举例2

再比如说这里，篮球运动员、足球运动员，大学生、小学生。篮球足球他们继承于叫运动员的类，学生这块儿继承学生类，这个是现有的继承关系。

现在有一个叫学英语这样的一个接口，这个接口它封装了一定的功能，或者说这个接口定义了学英语的一些规范。

比如说让足球运动员，大学生，不管是谁，如果你们想学英语，想遵循这样的一个接口的规范，你就实现这个接口就可以了。这是我们用的这个关系叫实现。

实现以后，足球运动员和大学生，他们就能够去学英语了。父类该是谁还是谁，不受影响。

3. 举例3

再比如，看下面的图：

这个飞机也好，子弹也好，风筝也好，热气球也好，这块儿都是不同场景的具体的类。

这呢，我们只考虑实现的关系。

现在呢，有一个接口，它表示的就是可以飞这样的功能，或者叫规范，我们定义到这个接口里了。

然后你发现飞机也好，子弹也好，风筝也好，热气球，它们都可以飞，那我就可以让它们去实现这个接口。或者换句话说，当你实现这个接口以后，体现为就是你们可以飞了。

然后这还有一个接口叫攻击性，其实可以看到这里都不是名词了，以前讲父类的话，其实都是一个具体的载体，是一个名词，现在都是一种功能的封装。

这个子弹具备攻击性，那我就让子弹也实现这个接口，实现这个接口以后，它就具备了这样的一个功能。

所以从这个角度来讲呢，实现接口跟上一个例子继承的父类，它确实是不同场景。

4. 举例4

刚才提到了规范的问题，只要你实现了这个规范，你就具备这个规范里边定义的一些相关的功能。

那么关于规范这个事儿，再唠叨两句，怎么体现叫规范呢？

刚才我们也说了，USB呢是定义了跟电脑通信的一种规范。谁实现了这个规范，谁就能够跟电脑进行数据传输。
这块呢又举了个例子。

这个例子的话，是在讲完这个java基础以后，大家可以学的一门技术，叫做jdbc，什么叫jdbc呢？它实际上是一波api。说白了就是一些类库，这个类库里边，主要的就是接口。

那这个接口是干什么用的呢？它就是规范了我们用JAVA程序操作不同数据库的一组规范。

以前的话，比如没有JDBC，直接用JAVA程序去操作具体的数据库就可以了，但是这样写程序的话，会不具备通用性。像MySQL跟Oracle是不同的数据库，可能这个细节差别很大，你用JAVA程序连的MySQL，再拿这个代码去连Oracle肯定不好使。所以需要重新再去写一套代码去连Oracle，包括这个DB2也同样的道理。

显然就感觉一致性很差，怎么办呢？现在Sun公司他出面定一套标准，这套标准呢，就是有好多的接口，那么这套标准合在一起就叫做JDBC，所以对于JAVA程序员来讲，你不要去面向具体的数据库去编程了，你只面向我这套接口编程就行。需要具备什么样功能，我这都定义好了，你直接去实现我这个接口，实现完以后的话，再去提供下边这些实现类。

因为是面向接口编程的，它封装了不同数据库厂商的细节。

比如现在操作的是Oracle，后期想改成MySQL，其实这块儿呢，非常简单，因为不同的数据库厂商都针对这套接口，就是这个标准进行了相关的一些改造了，都满足这套标准了。然后在连接MySQL的时候，这个代码其实变动很小，直接就可以来操作MySQL。

这就使得代码具备很好的移植性。

这就体现了接口它的作用，它就是一套规范。

Java程序是否能够连接使用某种数据库产品，那么要看该数据库产品能否实现Java设计的JDBC规范。

接口的本质是契约、标准、规范，就像我们的法律一样。制定好后大家都要遵守。

比如制定了JDBC这样一套规范，里边主要是接口大，大家都遵循这套接口和规范。那我们再去编程的时候，这个代码就具备一致性、规范性。

USB也同样道理，全世界范围内USB的标准全是一样的，大家都去遵守。你去欧洲买USB的一个设备插到你电脑上照样也能用，因为这个标准都是一样的。

（4）定义格式及重点举例

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，枚举，接口，注解。

1. 接口的声明格式

[修饰符] interface 接口名{
    //接口的成员列表：
    // 公共的静态常量
    // 公共的抽象方法
    
    // 公共的默认方法（JDK1.8以上）
    // 公共的静态方法（JDK1.8以上）
    // 私有方法（JDK1.9以上）
}

示例代码：

package com.atguigu.interfacetype;

public interface USB3{
    //静态常量
    long MAX_SPEED = 500*1024*1024;//500MB/s

    //抽象方法
    void in();
    void out();

    //默认方法
    default void start(){
        System.out.println("开始");
    }
    default void stop(){
        System.out.println("结束");
    }

    //静态方法
    static void show(){
        System.out.println("USB 3.0可以同步全速地进行读写操作");
    }
}

2. 接口的成员说明

①在JDK8.0 之前，接口中只允许出现：

（1）公共的静态的常量：其中public static final可以省略

（2）公共的抽象的方法：其中public abstract可以省略

理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现

②在JDK8.0 时，接口中允许声明默认方法和静态方法：

（3）公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略

（4）公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略

③在JDK9.0 时，接口又增加了：

（5）私有方法

除此之外，接口中没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化。

3. 接口内部结构的说明

<1> 接口的理解：接口的本质是契约、标准、规范，就像我们的法律一样。制定好后大家都要遵守。

<2> 定义接口的关键字：interface

<3> 接口内部结构的说明：

可以声明：
- 属性：必须使用public static final修饰（全局常量–不能改），不能声明变量。
- 方法：
  - jdk8之前：声明抽象方法，修饰为public abstract
  - jdk8：声明静态方法、默认方法（自己用的少，一般源码会用）
  - jdk9：声明私有方法（自己用的少，一般源码会用）
不可以声明：构造器、代码块等（接口跟抽象类一样也不能造对象，接口压根没有构造器）

4. 举例

4.1 举例1–接口

①属性

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MIN_SPEED);  //可以直接拿结构调用

        System.out.println(Flyable.MAX_SPEED);  //就算MAX_SPEED前面没有写static，也可以调用

        //Flyable.MAX_SPEED=7000;   //报错，MAX_SPEED是常量
    }
}

interface Flyable{  //接口
    //1.全局常量
    public static final int MIN_SPEED=0;      //能飞行的最低速度

    //public static final可以不写
    int MAX_SPEED=7900;   //能飞行的最高速度

}

final体现也可以证明，比如修改它的值，会报错，如下：

由于属性一般有 public static final 声明，所以可以省略。

②方法

interface Flyable{  //接口

    //2.方法（JDK8之前，只能写抽象方法）
    //可以省略 public abstract 声明
    public abstract void fly();

}

由于抽象方法一般都有 public abstract声明，所以可以省略。

4.2 举例2–类实现接口

再比如“攻击性”。

interface Attackable{   //接口
    public abstract void attack();
}

现在来提供具体接口的实现类。

类实现接口之后，接口里面的属性、方法也都拿过来了。

class Plane implements Flyable{

}

目前会报错，如下：

报错的原因是因为接口的抽象方法，两方面处理，要么写成一个抽象类，要么就将抽象方法实现以下。

比如：

//方法一、抽象类
abstract class Plane implements Flyable{

}

//方法二、重写抽象方法
class Bullet implements Flyable{

    @Override
    public void fly() {

    }
}

若将抽象方法实现了，相对应就可以实例化了。

我们也可以实现两个接口，同样会拥有它们所有的抽象方法，都需要重写，比如：

//重写抽象方法
class Bullet implements Flyable,Attackable{

    @Override
    public void fly() {

    }

    @Override
    public void attack() {

    }
}

那么后续操作就和以前一样了，比如可以通过类造对象并调方法。比如：

package yuyi01;

/**
 * ClassName: InterfaceTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/26 0026 9:22
 */
public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MIN_SPEED);  //可以直接拿结构调用

        System.out.println(Flyable.MAX_SPEED);  //就算MAX_SPEED前面没有写static，也可以调用

        //Flyable.MAX_SPEED=7000;   //报错，MAX_SPEED是常量

        Bullet b1=new Bullet();
        b1.fly();
        b1.attack();
    }
}

interface Flyable{  //接口
    //1.全局常量
    public static final int MIN_SPEED=0;      //能飞行的最低速度

    //public static final可以不写
    int MAX_SPEED=7900;   //能飞行的最高速度


    //2.方法（JDK8之前，只能写抽象方法）
    //可以省略 public abstract 声明
    public abstract void fly();

}

interface Attackable{   //接口
    public abstract void attack();
}

//抽象类
abstract class Plane implements Flyable{

}

//重写抽象方法
class Bullet implements Flyable,Attackable{

    @Override
    public void fly() {
        System.out.println("让子弹飞一下");
    }

    @Override
    public void attack() {
        System.out.println("子弹可以击穿石头");
    }
}

输出结果：

🗳️总结

<1> 接口与类的关系：实现关系

<2> 格式：class A extends SuperA implements B,C{}

A相较于SuperA来讲，叫做子类。

A相较于B,C来讲，叫做实现类。

<3> 满足此关系之后的说明：

类可以实现多个接口。（实现功能的扩充–多实现）
类针对于接口的多实现，一定程度上就弥补了类的单继承的局限性。
类必须将实现的接口中的所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类。

4.3 举例3–接口与接口

将D实现CC，那么类 D里面就相当于有两个方法，要想实例化，就需要都重写一下。

//测试接口的继承关系
interface AA{
    void method1();
}

interface BB{
    void method2();
}

interface CC extends AA,BB{    //接口多继承  相较于AA,BB来说，CC是子接口

}
class D implements CC{
    @Override
    public void method1() {
        
    }

    @Override
    public void method2() {

    }  //将D实现CC，那么类 D里面就相当于有两个方法，要想实例化，就需要都重写一下

}

接口与接口的关系：继承关系，且可以多继承。

4.4 举例4–接口与多态性

接口的多态性： 接口名变量名 = new 实现类对象; （new的不是什么子接口，接口本身没有构造器，不能造对象，这里要造对象，所以肯定是“实现类对象”）

4.4.1 案例1–虚方法调用

其实就是虚方法调用，跟讲类的多态性时候一样。

编译时定位到接口Flyable里面，但是运行的时候是实现类Bullet()里面的。

//接口的多态性
Flyable f1=new Bullet();
f1.fly();   //编译时定位到接口Flyable里面，但是运行的时候是实现类Bullet()里面的

调式：
问题5.gif

运行结果：

4.4.2 案例2–创建接口实现类的对象

用接口体现的是“规范”，实际new的时候都是“实现类的对象”。

比如：

🌱代码（场景一）

package yuyi01;

/**
 * ClassName: USBTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/26 0026 15:59
 */
public class USBTest {
    public static void main(String[] args) {
    	//场景一: 创建接口实现类(Printer)的对象(printer)
        
        //造一个电脑
        Computer computer=new Computer();   //computer类调用抽象接口的抽象方法，具体类实现抽象接口（重写方法）

        //造一个打印机
        Printer printer=new Printer();

        //在电脑上连打印机
        computer.transferData(printer); //transferData()方法里面声明的是USB类型，实际赋值的是Printer类型。即：USB usb=new Printer();

    }
}

//电脑
class Computer{
    public void transferData(USB usb){
        System.out.println("设备连接成功...");
        usb.start();

        System.out.println("数据传输细节操作...");

        usb.stop();
    }
}

//打印机
class Printer implements USB{   //打印机实现USB接口

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

//USB接口
interface USB{
    //声明常量，比如USB的长、宽、高...

    //方法
    public abstract void start();

    void stop();
}

🍺输出结果：

编译的时候看似调用的是USB的方法，实际执行的时候是具体打印机里面的方法。

多态性的体现：

//在电脑上连打印机
computer.transferData(printer); //transferData()方法里面声明的是USB类型，实际赋值的是Printer类型。即：USB usb=new Printer();

接口要是没有多态性就废了，接口本身也没有构造器，无法造对象，也不让实现类的对象直接赋，那么这块就没法赋值了。

class Computer{
    public void transferData(USB usb){
        //...
    }
}

🚗题外话

现在都是win 10 、win 11了，以前用这个XP啊，或者包括WIN 7的时候，你会发现经常一连外部设备，

它这块儿会联网操作，然后会提示一个说安装相关的驱动，这个驱动是什么？

驱动其实就是这个USB接口，它这一套标准已经定义好了，但是你连接这个外部设备，不知道你是什么，你要是连接我这个电脑，想进行数据传输的话，你得提供这一套实现类。我这只有一个接口，实际上的话它有好多接口，你得提供这样的一套实现类，那么这一套实现类的集合就是驱动。

比如说扫描仪想在电脑上去传输，扫描仪连上电脑之后，到底怎么传呀？这个USB是有一套标准，但是这都是抽象方法，这块儿你得把你的这套驱动先加载进来，或者要是联网的话，去下载一个也行，那就相当于提供了一套，就是实现了接口的这样一套实现类。然后电脑跟你去传的时候，就按照这套实现类里边实现的这种方法去做了。

4.4.3 案例3–创建接口实现类的匿名对象

再写一个照相机：

//照相机
class Camera implements USB{

    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("照相机结束工作");
    }
}

🌱整体代码（场景二）

package yuyi01;

/**
 * ClassName: USBTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/26 0026 15:59
 */
public class USBTest {
    public static void main(String[] args) {
        //造一个电脑
        Computer computer=new Computer();   //computer类调用抽象接口的抽象方法，具体类实现抽象接口（重写方法）

        //场景一:创建接口实现类(Printer)的对象(printer)
        //造一个打印机
        Printer printer=new Printer();

        //在电脑上连打印机
        computer.transferData(printer); //transferData()方法里面声明的是USB类型，实际赋值的是Printer类型。即：USB usb=new Printer();

        System.out.println();

        //场景二:创建接口实现类的匿名对象
        computer.transferData(new Camera());

    }
}

//电脑
class Computer{
    public void transferData(USB usb){
        System.out.println("设备连接成功...");
        usb.start();

        System.out.println("数据传输细节操作...");

        usb.stop();
    }
}

//打印机
class Printer implements USB{   //打印机实现USB接口

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

//照相机
class Camera implements USB{

    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("照相机结束工作");
    }
}


//USB接口
interface USB{
    //声明常量，比如USB的长、宽、高...

    //方法
    public abstract void start();

    void stop();
}

🍺输出结果

4.4.4 案例4–创建接口匿名实现类的对象

之前写了两个场景了，现在再来看一个。

public class USBTest {
    public static void main(String[] args) {
        //场景一: 创建接口实现类(Printer)的对象(printer)
        Computer computer=new Computer(); //造一个电脑
        Printer printer=new Printer();	//造一个打印机
        computer.transferData(printer); //在电脑上连打印机   USB usb=new Printer();


        //场景二: 创建接口实现类的匿名对象
        computer.transferData(new Camera());


        //场景三: 创建接口匿名实现类的对象
        computer.transferData();
    }
}

computer.transferData();

里面要传一个USB的实现类的对象，场景一是Printer，场景二是Camera，实现类都有名；

现在若实现类没有名了，要想声明一个变量怎么办呢？只能先拿USB顶替一下，对象有名，比如叫usb1：USB usb1=。

等号右边咋写？new一个啥呢？new一个构造器？构造器要与类同名，比如场景二是new Camera()，那么类就是Camera()。

此时对象有个名叫usb1，但是类没有。

那我们就new一个USB()，然后将usb1当作实参放入computer.transferData();中。如下：

USB usb1=new USB();
computer.transferData(usb1);

此时是报错状态，如下：

此时报错很正常，因为USB本身没有构造器。

现在这个实现类没有名，但是形式上又得这样写，此时拿USB充当了一下。但是实现类又要保证不是抽象类，这样才能够造对象，USB是充当了，但是它里面有抽象方法啊（抽象方法不能够造对象了）。如下：

//USB接口
interface USB{
    //声明常量，比如USB的长、宽、高...

    //方法
    public abstract void start();

    void stop();
}

🍸那咋办呢？

我们可以临时将USB里面的抽象方法给重写一下。

直接在后面整一对大括号，如下：

USB usb1=new USB(){

};

然后在里面重写抽象方法即可，如下：

//场景三: 创建接口匿名实现类的对象
USB usb1=new USB(){
    public void start(){
        System.out.println("U盘开始工作");
    }

    public void stop(){
        System.out.println("U盘结束工作");
    }
};
computer.transferData(usb1);

🌱整体代码（场景三）

package yuyi01;

/**
 * ClassName: USBTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/26 0026 15:59
 */
public class USBTest {
    public static void main(String[] args) {
        //造一个电脑
        Computer computer=new Computer();   //computer类调用抽象接口的抽象方法，具体类实现抽象接口（重写方法）

        //场景一:创建接口实现类(Printer)的对象(printer)
        //造一个打印机
        Printer printer=new Printer();
        //在电脑上连打印机
        computer.transferData(printer); //transferData()方法里面声明的是USB类型，实际赋值的是Printer类型。即：USB usb=new Printer();

        System.out.println();   //换行

        //场景二:创建接口实现类的匿名对象
        computer.transferData(new Camera());

        System.out.println();   //换行

        //场景三: 创建接口匿名实现类的对象
        USB usb1=new USB(){
            public void start(){
                System.out.println("U盘开始工作");
            }

            public void stop(){
                System.out.println("U盘结束工作");
            }
        };
        computer.transferData(usb1);
    }
}

//电脑
class Computer{
    public void transferData(USB usb){
        System.out.println("设备连接成功...");
        usb.start();

        System.out.println("数据传输细节操作...");

        usb.stop();
    }
}

//打印机
class Printer implements USB{   //打印机实现USB接口

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

//照相机
class Camera implements USB{

    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("照相机结束工作");
    }
}


//USB接口
interface USB{
    //声明常量，比如USB的长、宽、高...

    //方法
    public abstract void start();

    void stop();
}

🍺输出结果

🗃️絮叨

USB usb1=new USB(){
    //...
};

接口的匿名实现类，new后面要放实现类的类名，但现在实现类匿名，所以只能暂时用USB充当一下。

而类要是想造对象，必须要把抽象方法给实现一下，那么就在后面大括号临时实现一下即可。

现在对象是有名的。

4.4.5 案例5–创建接口匿名实现类的匿名对象

再来看一个场景。

此时类匿名，对象也匿名，很显然，在上一个场景的基础上，直接将new的部分当参数即可。

如下：

//场景四: 创建接口匿名实现类的匿名对象
computer.transferData(new USB(){//...});

写一下：

//场景四: 创建接口匿名实现类的匿名对象
computer.transferData(new USB(){
    public void start(){
        System.out.println("扫描仪开始工作");
    }

    public void stop(){
        System.out.println("扫描仪结束工作");
    }
});

这个也是多态性，可千万别说是new了一个接口USB的对象，是new了一个接口实现类的对象（只不过这个实现类没有名）。

🌱整体代码（场景四）

package yuyi01;

/**
 * ClassName: USBTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/26 0026 15:59
 */
public class USBTest {
    public static void main(String[] args) {
        //造一个电脑
        Computer computer=new Computer();   //computer类调用抽象接口的抽象方法，具体类实现抽象接口（重写方法）

        //场景一:创建接口实现类(Printer)的对象(printer)
        //造一个打印机
        Printer printer=new Printer();
        //在电脑上连打印机
        computer.transferData(printer); //transferData()方法里面声明的是USB类型，实际赋值的是Printer类型。即：USB usb=new Printer();

        System.out.println();   //换行

        //场景二:创建接口实现类的匿名对象
        computer.transferData(new Camera());

        System.out.println();   //换行

        //场景三: 创建接口匿名实现类的对象
        USB usb1=new USB(){
            public void start(){
                System.out.println("U盘开始工作");
            }

            public void stop(){
                System.out.println("U盘结束工作");
            }
        };
        computer.transferData(usb1);

        System.out.println();   //换行

        //场景四: 创建接口匿名实现类的匿名对象
        computer.transferData(new USB(){
            public void start(){
                System.out.println("扫描仪开始工作");
            }

            public void stop(){
                System.out.println("扫描仪结束工作");
            }
        });


    }
}

//电脑
class Computer{
    public void transferData(USB usb){
        System.out.println("设备连接成功...");
        usb.start();

        System.out.println("数据传输细节操作...");

        usb.stop();
    }
}

//打印机
class Printer implements USB{   //打印机实现USB接口

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

//照相机
class Camera implements USB{

    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("照相机结束工作");
    }
}


//USB接口
interface USB{
    //声明常量，比如USB的长、宽、高...

    //方法
    public abstract void start();

    void stop();
}

🍺输出结果

5 . 总结

🗳️总结

<1> 接口与类的关系：实现关系

<2> 格式：class A extends SuperA implements B,C{}

A相较于SuperA来讲，叫做子类。

A相较于B,C来讲，叫做实现类。

<3> 满足此关系之后的说明：

类可以实现多个接口。（实现功能的扩充–多实现）
类针对于接口的多实现，一定程度上就弥补了类的单继承的局限性。
类必须将实现的接口中的所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类。

<4> 接口与接口的关系：继承关系，且可以多继承

<5> 多态性

接口的多态性： 接口名变量名 = new 实现类对象; （new的不是什么子接口，接口本身没有构造器，不能造对象，这里要造对象，所以肯定是“实现类对象”）
类的多态性：父类变量名 = new 子类对象 ;

<6> 面试题：区分抽象类和接口

共性
- 都可以声明抽象方法。（抽象类可能没有抽象方法）
- 都不能实例化。（都不能创建对象）
不同
- 抽象类一定有构造器。接口没有构造器。
- 类与类之间继承关系，类与接口之间是实现关系，接口与接口之间是多继承关系。
- 抽象类中的属性可以随意定义，但是接口中只能是常量。

<7> 重点掌握四种场景

public class USBTest {
    public static void main(String[] args) {
        //场景一: 创建接口实现类(Printer)的对象(printer)
        Computer computer=new Computer(); //造一个电脑
        Printer printer=new Printer();	//造一个打印机
        computer.transferData(printer); //在电脑上连打印机   USB usb=new Printer();


        //场景二: 创建接口实现类的匿名对象
        computer.transferData(new Camera());


        //场景三: 创建接口匿名实现类的对象
        USB usb1=new USB(){
            public void start(){
                System.out.println("U盘开始工作");
            }

            public void stop(){
                System.out.println("U盘结束工作");
            }
        };
        computer.transferData(usb1);


        //场景四: 创建接口匿名实现类的匿名对象
        computer.transferData(new USB(){
            public void start(){
                System.out.println("扫描仪开始工作");
            }

            public void stop(){
                System.out.println("扫描仪结束工作");
            }
        });
    }
}

第一种最规范，但通常开发中会使用第三种和第四种，所以需要掌握。

<8> 接口存在多态性。

以后看到一个方法的形参是一个接口的时候，必然要使用多态。因为接口本身没有构造器，不能造对象，一定要放实现类的对象，即多态性。

//电脑
class Computer{
    public void transferData(USB usb){  //多态：USB usb=new Printer();
        System.out.println("设备连接成功...");
        usb.start();

        System.out.println("数据传输细节操作...");

        usb.stop();
    }
}

二、接口的使用规则

（1）类实现接口（implements）

接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

【修饰符】 class 实现类  implements 接口{
	// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

注意：

如果接口的实现类是非抽象类，那么必须重写接口中所有抽象方法。
默认方法可以选择保留，也可以重写。

重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了

接口中的静态方法不能被继承也不能被重写

举例：

interface USB{		// 
	public void start() ;
	public void stop() ;	
}
class Computer{
	public static void show(USB usb){	
		usb.start() ;
		System.out.println("=========== USB 设备工作 ========") ;
		usb.stop() ;
	}
};
class Flash implements USB{
	public void start(){	// 重写方法
		System.out.println("U盘开始工作。") ;
	}
	public void stop(){		// 重写方法
		System.out.println("U盘停止工作。") ;
	}
};
class Print implements USB{
	public void start(){	// 重写方法
		System.out.println("打印机开始工作。") ;
	}
	public void stop(){		// 重写方法
		System.out.println("打印机停止工作。") ;
	}
};
public class InterfaceDemo{
	public static void main(String args[]){
		Computer.show(new Flash()) ;
		Computer.show(new Print()) ;

		c.show(new USB(){
			public void start(){
				System.out.println("移动硬盘开始运行");
			}
			public void stop(){
				System.out.println("移动硬盘停止运行");
			}
		});
	}
};

（2）接口的多实现（implements）

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

【修饰符】 class 实现类  implements 接口1，接口2，接口3。。。{
	// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。。。{
    // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
  	// 重写接口中默认方法【可选】
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

举例：

定义多个接口：

package com.atguigu.interfacetype;

public interface A {
    void showA();
}

package com.atguigu.interfacetype;

public interface B {
    void showB();
}

定义实现类：

package com.atguigu.interfacetype;

public class C implements A,B {
    @Override
    public void showA() {
        System.out.println("showA");
    }

    @Override
    public void showB() {
        System.out.println("showB");
    }
}

测试类

package com.atguigu.interfacetype;

public class TestC {
    public static void main(String[] args) {
        C c = new C();
        c.showA();
        c.showB();
    }
}

（3）接口的多继承(extends)

一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法。

定义父接口：

package com.atguigu.interfacetype;

public interface Chargeable {
    void charge();
    void in();
    void out();
}

定义子接口：

package com.atguigu.interfacetype;

public interface UsbC extends Chargeable,USB3 {
    void reverse();
}

定义子接口的实现类：

package com.atguigu.interfacetype;

public class TypeCConverter implements UsbC {
    @Override
    public void reverse() {
        System.out.println("正反面都支持");
    }

    @Override
    public void charge() {
        System.out.println("可充电");
    }

    @Override
    public void in() {
        System.out.println("接收数据");
    }

    @Override
    public void out() {
        System.out.println("输出数据");
    }
}

所有父接口的抽象方法都有重写。

方法签名相同的抽象方法只需要实现一次。

（4）接口与实现类对象构成多态引用

实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。

接口的不同实现类：

package com.atguigu.interfacetype;

public class Mouse implements USB3 {
    @Override
    public void out() {
        System.out.println("发送脉冲信号");
    }

    @Override
    public void in() {
        System.out.println("不接收信号");
    }
}

package com.atguigu.interfacetype;

public class KeyBoard implements USB3{
    @Override
    public void in() {
        System.out.println("不接收信号");
    }

    @Override
    public void out() {
        System.out.println("发送按键信号");
    }
}

测试类

package com.atguigu.interfacetype;

public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        USB3 usb = new Mouse();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
        System.out.println("--------------------------");

        usb = new KeyBoard();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
        System.out.println("--------------------------");

        usb = new MobileHDD();
        computer.setUsb(usb);
        usb.start();
        usb.out();
        usb.in();
        usb.stop();
    }
}

（5）使用接口的静态成员

接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量。

package com.atguigu.interfacetype;

public class TestUSB3 {
    public static void main(String[] args) {
        //通过“接口名.”调用接口的静态方法 (JDK8.0才能开始使用)
        USB3.show();
        //通过“接口名.”直接使用接口的静态常量
        System.out.println(USB3.MAX_SPEED);
    }
}

（6）使用接口的非静态方法

对于接口的静态方法，直接使用“接口名.”进行调用即可
- 也只能使用“接口名."进行调用，不能通过实现类的对象进行调用
对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用
- 接口不能直接创建对象，只能创建实现类的对象

package com.atguigu.interfacetype;

public class TestMobileHDD {
    public static void main(String[] args) {
        //创建实现类对象
        MobileHDD b = new MobileHDD();

        //通过实现类对象调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就执行重写的默认方法，如果没有重写，就执行接口中的默认方法
        b.start();
        b.in();
        b.stop();

        //通过接口名调用接口的静态方法
//        MobileHDD.show();
//        b.show();
        Usb3.show();
    }
}

三、JDK8与JDK9中接口新特性

（1）说明

接口内部结构的说明：

可以声明：
属性：必须使用public static final修饰
方法：jdk8之前：声明抽象方法，修饰为public abstract
jdk8：声明静态方法、默认方法
jdk9：声明私有方法
不可以声明：构造器、代码块等

传统中，就按照这样来写：

但是从JDK8开始，它可以有方法体的方法了。其实自己写的比较少，更多的是源码层面，它会扩充一些有方法体的方法。可以直接使用。

接口与类：class A extends SuperA implements B,C{}

继承是单继承，现在可以实现多个接口。JDK8中，接口里面可以有方法体的方法了，可以直接拿给A用，一定程度上缓解了单继承的局限性。

（2）举例

1. 案例1–JDK8 静态方法

先来看JDK8中静态方法。

【CompareA.java】

package yuyi05;

/**
 * ClassName: CompareA
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 9:59
 */
public interface CompareA {
    //属性：声明为 public static final
    //方法：JDK8之前，只能声明抽象方法 public abstract

    //方法：JDK8--静态方法
    public static void method1(){
        System.out.println("CompareA:北京");
    }
}

可以看到，method1()就是静态方法，有方法体。和平时在类里面写静态方法一致，没什么区别。

那怎么用呢？

先写一个SubClass类，实现CompareA：

package yuyi05;

/**
 * ClassName: SubClass
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 10:03
 */
public class SubClass implements CompareA{

}

由于接口里面没有抽象方法，所以此时也没有报错，如下：

再写一个测试类SubClassTest：

public class SubClassTest {
    public static void main(String[] args) {

    }
}

现在接口CompareA里面有一个静态方法method1()，静态方法拿声明的主体去调应该就可以，比如：CompareA.method1();

运行发现可以：

如果用接口的实现类SubClass来调用这个方法，可以吗？

其实不可以，如下：

所以，实现类不可以调用！

知识点1：接口中声明的静态方法只能被接口调用，不能使用其实现类进行调用。

2. 案例2–JDK8 默认方法

2.1 默认方法

接下来看JDK8中默认方法。

这里要使用一个关键字default。

【CompareA.java】

public interface CompareA {
	//...
    //方法：JDK8--默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

}

就是在普通方法里面加了一个default。若是不加default，它就默认你省略了abstract，会认为此方法是一个抽象方法。如下：

既然SubClass实现了接口CompareA，那么这个默认方法method2()应该也可以拿到。

下面来做测试。

public class SubClassTest {
    public static void main(String[] args) {
        //...
        SubClass s1=new SubClass(); //因为是默认方法，不是静态，所以要造对象
        s1.method2();
    }
}

运行结果：

在SubClass类里面，也可以对接口CompareA里的方法做重写。比如：

public class SubClass implements CompareA{
    @Override
    public void method2() {
        System.out.println("SubClass:上海");
    }
}

再次测试，就会调用重写之后的方法了（与类类似），如下：

知识点2：接口中声明的默认方法可以被实现类继承，实现类在没有重写此方法的情况下，默认调用接口中声明的默认方法；如果实现类重写了此方法，则调用的是自己重写的方法。

2.2 接口冲突

在接口CompareA中再写一个默认方法method3()，如下：

public interface CompareA {
    //属性：声明为 public static final
    //方法：JDK8之前，只能声明抽象方法 public abstract

    //方法：JDK8--静态方法
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    //方法：JDK8--默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

    public default void method3(){
        System.out.println("CompareA:广州");
    }

}

然后再写一个接口CompareB，方法method3()的声明与接口CompareA中一致，如下：

public interface CompareB {
    //默认方法
    public default void method3(){
        System.out.println("CompareB:广州");
    }
}

现在SubClass实现了接口CompareA，那么SubClass也拿到了CompareA中的方法method3()。

此时让SubClass也实现接口CompareB，可以发现出错了：

前面说过“抽象方法”，若接口CompareA里面有一个抽象方法，接口CompareB里面也有一个抽象方法，CompareA和CompareB里面的抽象方法声明一致，那么此时SubClass会有上面的问题吗？

其实不会，

因为SubClass类要想造对象的话，需要把这个抽象方法重写一下，这个重写既可以看作是对CompareA里面抽象方法的重写，也可以看作是对CompareB里面抽象方法的重写。

若SubClass类没有重写抽象方法，而是一个抽象类，那也没有问题，因为它们的方法长得一样，没有方法体。

但是现在的情况是，接口CompareA和CompareB它们的默认方法有方法体，而且声明一样，那么在实现类SubClass没有重写的情况下就会冲突。

此时若在测试类里面调用method3()，编译器就不知道调用谁，因为接口的地位对于类来说完全一致，s1不知道该调用谁，就会报错。

我们将这种问题叫做“接口冲突”。

此时实现类必须要重写接口中定义的同名同参数的方法。

public class SubClass implements CompareA,CompareB{
    //...
    public  void method3(){ //类没有default之说，不用写它
        System.out.println("SubClass:广州");
    }
}

这个重写既可以看作是对CompareA里面method3()方法的重写，也可以看作是对CompareB里面method3()方法的重写。

然后在测试类里面调用method3()，就会是自己的方法了，如下：

知识点3：类实现了两个接口，而两个接口中定义了同名同参数的默认方法。则实现类在没有重写此两个接口默认方法的情况下会报错–>接口冲突

要求：此时实现类必须要重写接口中定义的同名同参数的方法。

2.3 类优先原则

现在在接口CompareA里面再加一个方法method4()：

public interface CompareA {
    //...
    public default void method4(){
        System.out.println("CompareA:深圳");
    }

}

然后再写一个类SuperClass，并将CompareA中的method4()粘过来（名字、参数都一样），如下：

public class SuperClass {
    public  void method4(){
        System.out.println("SuperClass:深圳");
    }
}

然后让SubClass继承于SuperClass：

可以发现，此时没有报错。

SuperClass里面有method4()，CompareA里面也有method4()，它们名字一样、参数一样，此时为啥不会报错呢？

这是因为类与接口的低位不平等。

若此时拿s1去调用method4()，结果如下：

可以发现，调用的是SuperClass类中的method4()方法。

将这种情况叫做“类优先原则”。

知识点4：子类（实现类）继承了父类并实现了接口，父类和接口中声明了同名同参数的方法。（对于接口来说，这是默认方法）

默认情况下，子类（实现类）在没有重写此方法的情况下，调用的是父类中的方法。—> 类优先原则

若子类重写了，那么调用的时候肯定就是重写之后的方法了，

2.4 在实现类中调用接口中被重写的方法

在SubClass类里面重写一下method4()方法：

public class SubClass extends SuperClass implements CompareA,CompareB{
    //...  
    public void method4(){
        System.out.println("SubClass:深圳");
    }
}

在测试类里面调用method4()就是调用自己重写的了：

此时在SubClass中，再写一个普通的方法，想调用自己方法中的method4()，直接method4()即可。

如果想调用父类中的method4()，加一个super.即可：super.method4()。

public class SubClass extends SuperClass implements CompareA,CompareB{
  	//...
    public void method(){
        method4();  //调用自己类中的方法
        
        super.method4();    //调用父类中的方法
        
    }
}

现在我想调用CompareA中的method3()，接口CompareA和接口CompareB中都有method3()，那怎么调用呢？

用CompareA调用吗？这样：CompareA..method3()。此时method3()不是静态的啊，所以不能这样调用。

那加一个super：CompareA.super.method3();就可以啦。

同理。调用CompareB里面的method3()：CompareB.super.method3();

这里的super也不是体现“父类的”了，就是继承了父类或者实现了接口，都算是super的场景（基于实例来说的）。

public class SubClass extends SuperClass implements CompareA,CompareB{
    //...
    public void method(){
        method4();  //调用自己类中的方法

        super.method4();    //调用父类中的方法

        CompareA.super.method3();   //调用接口CompareA中的默认方法
        CompareB.super.method3();   //调用接口CompareB中的默认方法
    }
}

知识点5：如何在子类（或实现类）中调用父类或接口中被重写的方法

比如，调用CompareB里面的method3()：CompareB.super.method3();

3. 案例3–JDK9 定义私有方法

“文件”–>“项目结构”：

这个地方用的17，如果是8就不行哦：

这种情况下就可以演示JDK9新特性了。比如：

public interface CompareA {
    //...
    //方法：JDK9新特性--定义私有方法
    private void method5(){
        System.out.println("我是接口CompareA中定义的私有方法");
    }

}

私有方法实现类也不能继承，这个方法干啥用呢？就是自己用。

刚才写的默认方法都有方法体，而且method5()也不是静态方法，不是给静态方法用的，就是给默认方法用的啦。

若定义了好多默认方法，彼此之间有一些共同的代码，可以将这些共同代码专门抽取出来，也不对外暴露了，就让它私有化。
就是这样使用。

（3）整体代码

这里将刚才举例的所有代码展现出来，供大家学习使用。

🌱代码

【CompareA.java】

package yuyi05;

/**
 * ClassName: CompareA
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 9:59
 */
public interface CompareA {
    //属性：声明为 public static final
    //方法：JDK8之前，只能声明抽象方法 public abstract

    //方法：JDK8--静态方法
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    //方法：JDK8--默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

    public default void method3(){
        System.out.println("CompareA:广州");
    }

    public default void method4(){
        System.out.println("CompareA:深圳");
    }

    //方法：JDK9新特性--定义私有方法
    private void method5(){
        System.out.println("我是接口CompareA中定义的私有方法");
    }

}

【CompareB.java】

package yuyi05;

/**
 * ClassName: CompareB
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 10:35
 */
public interface CompareB {
    //默认方法
    public default void method3(){
        System.out.println("CompareB:广州");
    }
}

【SubClass.java】

package yuyi05;

/**
 * ClassName: SubClass
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 10:03
 */
public class SubClass extends SuperClass implements CompareA,CompareB{
    @Override
    public void method2() {
        System.out.println("SubClass:上海");
    }

    public  void method3(){ //类没有default之说，不用写它
        System.out.println("SubClass:广州");
    }

    public void method4(){
        System.out.println("SubClass:深圳");
    }

    public void method(){
        method4();  //调用自己类中的方法

        super.method4();    //调用父类中的方法

        CompareA.super.method3();   //调用接口CompareA中的默认方法
        CompareB.super.method3();   //调用接口CompareB中的默认方法
    }
}

【SuperClass.java】

package yuyi05;

/**
 * ClassName: SuperClass
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 11:01
 */
public class SuperClass {
    public  void method4(){
        System.out.println("SuperClass:深圳");
    }
}

【SubClassTest.java】

package yuyi05;

/**
 * ClassName: SubClassTest
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/29 0029 10:05
 */
public class SubClassTest {
    public static void main(String[] args) {
        //知识点1：接口中声明的静态方法只能被接口调用，不能使用其实现类进行调用。
        CompareA.method1();
        //SubClass.method1();

        //知识点2：接口中声明的默认方法可以被实现类继承，实现类在没有重写此方法的情况下，默认调用接口中声明的默认方法；
        // 如果实现类重写了此方法，则调用的是自己重写的方法。
        SubClass s1=new SubClass(); //因为是默认方法，不是静态，所以要造对象
        s1.method2();

        //知识点3：类实现了两个接口，而两个接口中定义了同名同参数的默认方法。则实现类在没有重写此两个接口默认方法的情况下会报错-->接口冲突
        //要求：此时实现类必须要重写接口中定义的同名同参数的方法。
        s1.method3();

        //知识点4：子类（实现类）继承了父类并实现了接口，父类和接口中声明了同名同参数的方法。（对于接口来说，这是默认方法）
        //默认情况下，子类（实现类）在没有重写此方法的情况下，调用的是父类中的方法。--->类优先原则
        s1.method4();

        s1.method();
    }
}

🍺输出结果

四、JDK8中相关冲突问题

（1）默认方法冲突问题

1. 类优先原则

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的抽象方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

package com.atguigu.interfacetype;

public interface Friend {
    default void date(){//约会
        System.out.println("吃喝玩乐");
    }
}

定义父类：

package com.atguigu.interfacetype;

public class Father {
    public void date(){//约会
        System.out.println("爸爸约吃饭");
    }
}

定义子类：

package com.atguigu.interfacetype;

public class Son extends Father implements Friend {
    @Override
    public void date() {
        //(1)不重写默认保留父类的
        //(2)调用父类被重写的
//        super.date();
        //(3)保留父接口的
//        Friend.super.date();
        //(4)完全重写
        System.out.println("跟康师傅学Java");
    }
}

定义测试类：

package com.atguigu.interfacetype;

public class TestSon {
    public static void main(String[] args) {
        Son s = new Son();
        s.date();
    }
}

2. 接口冲突（左右为难）

当一个类同时实现了多个父接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

无论你多难抉择，最终都是要做出选择的。

声明接口：

package com.atguigu.interfacetype;

public interface BoyFriend {
    default void date(){//约会
        System.out.println("神秘约会");
    }
}

选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法。

package com.atguigu.interfacetype;

public class Girl implements Friend,BoyFriend{

    @Override
    public void date() {
        //(1)保留其中一个父接口的
//        Friend.super.date();
//        BoyFriend.super.date();
        //(2)完全重写
        System.out.println("跟康师傅学Java");
    }

}

测试类

package com.atguigu.interfacetype;

public class TestGirl {
    public static void main(String[] args) {
        Girl girl = new Girl();
        girl.date();
    }
}

当一个子接口同时继承了多个接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

另一个父接口：

package com.atguigu.interfacetype;

public interface USB2 {
    //静态常量
    long MAX_SPEED = 60*1024*1024;//60MB/s

    //抽象方法
    void in();
    void out();

    //默认方法
    public default void start(){
        System.out.println("开始");
    }
    public default void stop(){
        System.out.println("结束");
    }

    //静态方法
    public static void show(){
        System.out.println("USB 2.0可以高速地进行读写操作");
    }
}

子接口：

package com.atguigu.interfacetype;

public interface USB extends USB2,USB3 {
    @Override
    default void start() {
        System.out.println("Usb.start");
    }

    @Override
    default void stop() {
        System.out.println("Usb.stop");
    }
}

小贴士：

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

（2）常量冲突问题

当子类继承父类又实现父接口，而父类中存在与父接口常量同名的成员变量，并且该成员变量名在子类中仍然可见。
当子类同时实现多个接口，而多个接口存在相同同名常量。

此时在子类中想要引用父类或父接口的同名的常量或成员变量时，就会有冲突问题。

父类和父接口：

package com.atguigu.interfacetype;

public class SuperClass {
    int x = 1;
}

package com.atguigu.interfacetype;

public interface SuperInterface {
    int x = 2;
    int y = 2;
}

package com.atguigu.interfacetype;

public interface MotherInterface {
    int x = 3;
}

子类：

package com.atguigu.interfacetype;

public class SubClass extends SuperClass implements SuperInterface,MotherInterface {
    public void method(){
//        System.out.println("x = " + x);//模糊不清
        System.out.println("super.x = " + super.x);
        System.out.println("SuperInterface.x = " + SuperInterface.x);
        System.out.println("MotherInterface.x = " + MotherInterface.x);
        System.out.println("y = " + y);//没有重名问题，可以直接访问
    }
}

五、接口的总结与面试题

（1）总结

接口本身不能创建对象，只能创建接口的实现类对象，接口类型的变量可以与实现类对象构成多态引用。
声明接口用interface，接口的成员声明有限制：
- （1）公共的静态常量
- （2）公共的抽象方法
- （3）公共的默认方法（JDK8.0 及以上）
- （4）公共的静态方法（JDK8.0 及以上）
- （5）私有方法（JDK9.0 及以上）
类可以实现接口，关键字是implements，而且支持多实现。如果实现类不是抽象类，就必须实现接口中所有的抽象方法。如果实现类既要继承父类又要实现父接口，那么继承（extends）在前，实现（implements）在后。
接口可以继承接口，关键字是extends，而且支持多继承。
接口的默认方法可以选择重写或不重写。如果有冲突问题，另行处理。子类重写父接口的默认方法，要去掉default，子接口重写父接口的默认方法，不要去掉default。
接口的静态方法不能被继承，也不能被重写。接口的静态方法只能通过“接口名.静态方法名”进行调用。

（2）面试题

1、为什么接口中只能声明公共的静态的常量？

因为接口是标准规范，那么在规范中需要声明一些底线边界值，当实现者在实现这些规范时，不能去随意修改和触碰这些底线，否则就有“危险”。

例如：USB1.0规范中规定最大传输速率是1.5Mbps，最大输出电流是5V/500mA
USB3.0规范中规定最大传输速率是5Gbps(500MB/s)，最大输出电流是5V/900mA

例如：某校学生行为规范中规定学员，早上8:25之前进班，晚上21:30之后离开等等。

2、为什么JDK8.0 之后允许接口定义静态方法和默认方法呢？因为它违反了接口作为一个抽象标准定义的概念。

静态方法：

因为之前的标准类库设计中，有很多Collection/Colletions或者Path/Paths这样成对的接口和类，后面的类中都是静态方法，而这些静态方法都是为前面的接口服务的，那么这样设计一对API，不如把静态方法直接定义到接口中使用和维护更方便。

默认方法：

（1）我们要在已有的老版接口中提供新方法时，如果添加抽象方法，就会涉及到原来使用这些接口的类就会有问题，那么为了保持与旧版本代码的兼容性，只能允许在接口中定义默认方法实现。比如：Java8中对Collection、List、Comparator等接口提供了丰富的默认方法。

（2）当我们接口的某个抽象方法，在很多实现类中的实现代码是一样的，此时将这个抽象方法设计为默认方法更为合适，那么实现类就可以选择重写，也可以选择不重写。

3、为什么JDK1.9要允许接口定义私有方法呢？因为我们说接口是规范，规范是需要公开让大家遵守的。

私有方法：因为有了默认方法和静态方法这样具有具体实现的方法，那么就可能出现多个方法由共同的代码可以抽取，而这些共同的代码抽取出来的方法又只希望在接口内部使用，所以就增加了私有方法。

六、接口与抽象类之间的对比

【区分抽象类和接口】

共性
- 都可以声明抽象方法。（抽象类可能没有抽象方法）
- 都不能实例化。（都不能创建对象）
不同
- 抽象类一定有构造器。接口没有构造器。
- 类与类之间继承关系，类与接口之间是实现关系，接口与接口之间是多继承关系。
- 抽象类中的属性可以随意定义，但是接口中只能是常量。

☕总结如下图：

在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口。

七、练习

（1）练习1

🌋题目描述

1、声明接口Eatable，包含抽象方法public abstract void eat();。

2、声明实现类中国人Chinese，重写抽象方法，打印用筷子吃饭。

3、声明实现类美国人American，重写抽象方法，打印用刀叉吃饭。

4、声明实现类印度人Indian，重写抽象方法，打印用手抓饭。

5、声明测试类EatableTest，创建Eatable数组，存储各国人对象，并遍历数组，调用eat()方法。

🌱代码

【Eatable.java】

package yuyi02;

/**
 * ClassName: Eatable
 * Package: yuyi02
 * Description:
 *      1、声明接口Eatable，包含抽象方法public abstract void eat();
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 9:37
 */
public abstract interface Eatable {  //接口
    public abstract void eat();
}

【Chinese.java】

package yuyi02;

/**
 * ClassName: Chinese
 * Package: yuyi02
 * Description:
 *      2、声明实现类中国人Chinese，重写抽象方法，打印用筷子吃饭
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 9:39
 */
public class Chinese implements Eatable{
    @Override
    public void eat() {
        System.out.println("中国人使用筷子吃饭");
    }
}

【American.java】

package yuyi02;

/**
 * ClassName: American
 * Package: yuyi02
 * Description:
 *      3、声明实现类美国人American，重写抽象方法，打印用刀叉吃饭
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 9:46
 */
public class American implements Eatable{
    @Override
    public void eat() {
        System.out.println("美国人使用刀叉吃饭");
    }
}

【Indian.java】

package yuyi02;

/**
 * ClassName: Indian
 * Package: yuyi02
 * Description:
 *      4、声明实现类印度人Indian，重写抽象方法，打印用手抓饭
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 9:49
 */
public class Indian implements Eatable{
    @Override
    public void eat() {
        System.out.println("印度人使用手抓吃饭");
    }
}

【EatableTest.java】

package yuyi02;

/**
 * ClassName: EatableTest
 * Package: yuyi02
 * Description:
 *      5、声明测试类EatableTest，创建Eatable数组，存储各国人对象，并遍历数组，调用eat()方法
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 9:50
 */
public class EatableTest {
    public static void main(String[] args) {
        //new的是一个数组，数组这里指明的是元素的类型，类型是Eatable，new的并不是构造器，只是指明了元素类型
        Eatable[] eatables=new Eatable[3];  //接口类型3个元素

        //创建实现类对象，并赋值给数组元素
        eatables[0]=new Chinese(); //针对数组中每个元素进行赋值，这后边new的是构造器
        eatables[1]=new American();
        eatables[2]=new Indian();

        //遍历数组
        for (int i = 0; i < eatables.length; i++) {
            eatables[i].eat();
        }
    }
}

🍺输出结果

🍹注意

//new的是一个数组，数组这里指明的是元素的类型，类型是Eatable，new的并不是构造器，只是指明了元素类型
Eatable[] eatables=new Eatable[3];  //接口类型3个元素

//创建实现类对象，并赋值给数组元素
eatables[0]=new Chinese(); //针对数组中每个元素进行赋值，这后边new的是构造器
eatables[1]=new American();
eatables[2]=new Indian();

只要声明接口了，给它实例化的时候，一定是实现类的对象，必然要体现多态性。

只要有接口的地方就有多态性！

（2）练习2

🌋题目描述

1、定义一个接口用来实现两个对象的比较。

interface CompareObject{
   //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
   public int compareTo(Object o);
}

2、定义一个Circle类，声明radius属性，提供getter和setter方法。

3、定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。

在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。

4、定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。

拓展：参照上述做法定义矩形类Rectangle和ComparableRectangle类，在ComparableRectangle类中给出compareTo方法的实现，比较两个矩形的面积大小。

🌱代码

【Circle.java】

package yuyi03;

/**
 * ClassName: Circle
 * Package: yuyi03
 * Description:
 *      定义一个Circle类，声明radius属性，提供getter和setter方法
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:52
 */
public class Circle {   //两个Circle对象不能够比较大小
    public double radius;   //半径

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle() {

    }

    public Circle(double radius) {
        this.radius = radius;
    }

    //toString方法
    @Override
    public String toString() {
        return "Circle{" +
        "radius=" + radius +
        '}';
    }
}

【CompareObject.java】

package yuyi03;

/**
 * ClassName: CompareObject
 * Package: yuyi03
 * Description:
 *      定义一个接口用来实现两个对象的比较。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 10:09
 */
public interface CompareObject {    //自定义一个接口来比较对象大小
    //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
    public int compareTo(Object o); //这个是抽象方法(省略了abstract)，虽然它没有方法体，但是这个方法是做什么的，形参是什么意思，返回值类型是什么都完全确定了，只是细节没有确定
}

【ComparableCircle.java】

package yuyi03;

/**
 * ClassName: ComparableCircle
 * Package: yuyi03
 * Description:
 *      定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。
 *      在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:56
 */
public class ComparableCircle extends Circle implements CompareObject{
    //根据对象半径的大小，比较对象的大小(和之前说的equals很像)
    @Override
    public int compareTo(Object o) {
        if(this==o){    //判断当前对象与o是不是指向同一个
            return 0;   //若地址一样，则半径肯定一致，直接返回0
        }
        if(o instanceof ComparableCircle){  //判断是否是当前类的对象
            ComparableCircle c=(ComparableCircle) o;    //若是当前类对象，先强转一下 (从父类对象强转成子类才能调用子类特有的结构)

            //错误的(逻辑上错误)
            //return (int) (this.getRadius()-c.getRadius());    //当两者整数部分都一致的时候，不靠谱

            //正确的写法1
            /*if(this.getRadius()>c.getRadius()){
                return 1;
            } else if (this.getRadius()<c.getRadius()) {
                return -1;
            }else{
                return 0;
            }*/

            //正确写法2
            return Double.compare(this.getRadius(),c.getRadius()); //API里面有一个类就叫Double，里面有一个方法叫compare()，里面传入两个double类型的值，就会自动比较它们的大小，返回的就是一个int类型的值，直接return即可

        }else{  //当这个对象不是当前实例
            throw new RuntimeException("输入类型不匹配");
        }

    }

    public ComparableCircle() {

    }

    public ComparableCircle(double radius) {
        super(radius);
    }
}

【InterfaceTest.java】

package yuyi03;

/**
 * ClassName: InterfaceTest
 * Package: yuyi03
 * Description:
 *      定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 15:43
 */
public class InterfaceTest {
    public static void main(String[] args) {
        ComparableCircle c1=new ComparableCircle(2.3);
        ComparableCircle c2=new ComparableCircle(5.3);

        int compareValue=c1.compareTo(c2);
        if(compareValue>0){
            System.out.println("c1对象大");
        } else if (compareValue<0) {
            System.out.println("c2对象大");
        }else {
            System.out.println("c1与c2一样大");
        }
    }
}

🍺输出结果

🍹注意

//根据对象半径的大小，比较对象的大小(和之前说的equals很像)
@Override
public int compareTo(Object o) {
    if(this==o){    //判断当前对象与o是不是指向同一个
        return 0;   //若地址一样，则半径肯定一致，直接返回0
    }
    if(o instanceof ComparableCircle){  //判断是否是当前类的对象
        ComparableCircle c=(ComparableCircle) o;    //若是当前类对象，先强转一下
        return (int) (this.getRadius()-c.getRadius());
    }
	//...
}

注意return (int) (this.getRadius()-c.getRadius());这里强转是不好使的（因为半径radius是double类型的）。

若this.getRadius()是2.5，c.getRadius()是2.1，那么this.getRadius()-c.getRadius()则是2.5-2.1=0.4，经过强转就是0，0表示两个对象相等，不靠谱。

API里面有一个类就叫Double，里面有一个方法叫compare()，里面传入两个double类型的值，就会自动比较它们的大小，返回的就是一个int类型的值，直接return即可。

//正确写法2
return Double.compare(this.getRadius(),c.getRadius());

当这个对象不是当前实例的时候，相当于这两个对象就没有办法比较，此时还必须要一个返回值，但是 return 任何一个值都不太合适。

若是返回大于0的数，则当前对象大；若为0，则一样大；若是小于0，则当前小。

以后会说“异常”，这个时候就可以拋一个异常，在异常里面写“输入的类型不匹配”即可。（这里需要的类型是ComparableCircle，结果传过来的不是这个类型，没法比较）

else{  //当这个对象不是当前实例
    throw new RuntimeException("输入类型不匹配");
}

只要你实现CompareObject接口（这个接口用于定义比较大小的事儿），就需要重写compareTo这个方法，只要重写了这个方法，就知道谁大谁小。

（3）练习3

🌋题目描述

阿里的一个工程师Developer,结构见图。

其中，有一个乘坐交通工具的方法takingVehicle()，在此方法中调用交通工具的run()。

为了出行方便，他买了一辆捷安特自行车、一辆雅迪电动车和一辆奔驰轿车。这里涉及到的相关类及接口关系如图。

其中，电动车增加动力的方式是充电，轿车增加动力的方式是加油。在具体交通工具的run()中调用其所在类的相关属性信息。
请编写相关代码，并测试。

提示：创建Vehicle[]数组，保存阿里工程师的三辆交通工具，并分别在工程师的takingVehicle()中调用。

🌱代码

【Developer.java】

package yuyi04;

/**
 * ClassName: Developer
 * Package: yuyi04
 * Description:
 *      阿里的一个工程师Developer,结构见图。
 *      其中，有一个乘坐交通工具的方法takingVehicle()，在此方法中调用交通工具的run()。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:15
 */
public class Developer {
    private String name;
    private int age;

    public Developer() {

    }

    public Developer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void takingVehicle(Vehicle vehicle){
        vehicle.run();
    }
}

【IPower.java】

package yuyi04;

/**
 * ClassName: IPower
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:40
 */
public interface IPower {
    void power();
}

【Vehicle.java】

package yuyi04;

/**
 * ClassName: Vehicle
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:21
 */
public abstract class Vehicle { //abstract抽象类，不能实例化(创建对象)
    private String brand;   //品牌
    private String color;   //颜色

    public Vehicle() {

    }

    public Vehicle(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract void run(); //接口里面可以省略public abstract，抽象类里面不可以
}

【Bicycle.java】

package yuyi04;

/**
 * ClassName: Bicycle
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:30
 */
public class Bicycle extends Vehicle{
    @Override
    public void run() {
        System.out.println("自行车通过人力行驶");
    }

    public Bicycle() {

    }

    public Bicycle(String brand, String color) {
        super(brand, color);
    }
}

【ElectricVehicle.java】

package yuyi04;

/**
 * ClassName: ElectricVehicle
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:34
 */
public class ElectricVehicle extends Vehicle implements IPower{
    @Override
    public void run() {
        System.out.println("电动车通过电机驱动行驶");
    }

    public ElectricVehicle() {

    }

    public ElectricVehicle(String brand, String color) {
        super(brand, color);
    }

    @Override
    public void power() {
        System.out.println("电动车使用电力提供动力");
    }
}

【Car.java】

package yuyi04;

/**
 * ClassName: Car
 * Package: yuyi04
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:36
 */
public class Car extends Vehicle implements IPower{
    private String carNumber;

    @Override
    public void run() {
        System.out.println("汽车通过内燃机驱动行驶");
    }

    public Car() {

    }

    public Car(String brand, String color, String carNumber) {
        super(brand, color);
        this.carNumber = carNumber;
    }

    public String getCarNumber() {
        return carNumber;
    }

    public void setCarNumber(String carNumber) {
        this.carNumber = carNumber;
    }

    @Override
    public void power() {
        System.out.println("汽车通过汽油提供动力");
    }
}

【VehicleTest.java】

package yuyi04;

/**
 * ClassName: VehicleTest
 * Package: yuyi04
 * Description:
 *      为了出行方便，他买了一辆捷安特自行车、一辆雅迪电动车和一辆奔驰轿车。这里涉及到的相关类及接口关系如图。
 *      其中，电动车增加动力的方式是充电，轿车增加动力的方式是加油。在具体交通工具的run()中调用其所在类的相关属性信息。
 *
 *      提示：创建Vehicle[]数组，保存阿里工程师的三辆交通工具，并分别在工程师的takingVehicle()中调用。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 17:45
 */
public class VehicleTest {
    public static void main(String[] args) {
        //创建一个工程师
        Developer developer=new Developer();

        //创建三个交通工具，保存在数组中（数组的类型是三个交通工具的共同类型）
        Vehicle[] vehicles=new Vehicle[3];  //声明了3个元素的数组结构，每个元素是Vehicle，并不是new了一个构造器
        vehicles[0]=new Bicycle("捷安特","红色");
        vehicles[1]=new ElectricVehicle("爱玛","蓝色");
        vehicles[2]=new Car("奔驰","黑色","皖P666");

        for (int i = 0; i < vehicles.length; i++) {
            developer.takingVehicle(vehicles[i]);

            if(vehicles[i] instanceof IPower){  //接口这儿仍然可以这样来写
                ((IPower) vehicles[i]).power();
            }
        }

    }
}

🍺输出结果

🍹注意

Ctrl+I可以调出接口要重写的方法。

比如：

则可以自动生成：

@Override
public void power() {

}

编译看左边，运行看右边。这是多态的体现，虽然编译的时候，点进去是在vehicle类中，但真正执行run方法的是实现父类抽象方法的子类。

这个是自己加的新功能，题目中并没有要求。

接口也可以这样来写：

if(vehicles[i] instanceof IPower){  //接口这儿仍然可以这样来写

}

当然，此时用vehicles[i]调用power()方法是不可以的，如下：

vehicles[i]本身没有power()方法，所以此时需要强转，如下：

if(vehicles[i] instanceof IPower){  //接口这儿仍然可以这样来写
    ((IPower) vehicles[i]).power();
}

Vechicles类型是父类，没有重写接口的power方法，我们需要将其类型转化为Ipower类型的。