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

-> Java知识库 -> 04-面向对象进阶-接口-接口成员特点、接口与类(接口与接口，类与类)之间关系、接口新特性(default、static方法) -> 正文阅读

[Java知识库]04-面向对象进阶-接口-接口成员特点、接口与类(接口与接口，类与类)之间关系、接口新特性(default、static方法)

文章目录

小知识
- 1. 接口成员方法默认都是 public abstract (可少写不写不可错写)
- 2.同理，接口中变量默认都是public static final (可少写不写不可错写)

1.接口

1.1 引入

抽取出一个父类，父类所有方法都无法具体实现，也就是父类变成了全部是抽象方法的抽象类(抽象类是允许带有非抽象方法的)，此时这个类直接就是用来制定规则的，

在这里插入图片描述

接口存在的两个重要意义

规则的定义
程序的拓展性

在这里插入图片描述

1.2 接口的概述（理解）

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中接口存在的两个意义
1. 用来定义规范
2. 用来做功能的拓展

1.3 接口的特点（记忆）

接口用关键字interface修饰
```
public interface 接口名 {} 
```

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化

? 我们可以创建接口的实现类对象使用
接口的子类

? 要么重写接口中的所有抽象方法

? 要么子类也是抽象类

1、java单继承，不支持多继承
但是java支持多实现，一个类可以同时实现多个接口，重写所有抽象方法后才不用做抽象类)
2、实现类实现接口的方法，也称为重写(和子类继承父类重写非常像），从此处看其实也就是用接口机制变相实现了c++里的多继承【继承理解为亲爹，实现接口理解为认干爹亲爹只有一个但是干爹随便认】
3、class A implements I1,I2{…} I1和I2接口可以有完全一样的重复抽象方法(很像c里面的方法声明)，A里有一份实现即可，没有逻辑冲突语法错误啥的

1.4 接口的成员特点（记忆）

1.4.1 成员变量

?	 只能是 公有有静态常量

?	 默认修饰符：public static final  (可以少写不写 默认都会帮你加上 但是不能错写 比如:private)

public interface Inter {
    
    final static  int num=10;//以后都要大写NUM
    /*
        成员变量默认修饰符: public static final
        无论写: int num=10;
               final int num=10;
               static int num=10;
               static final num=10;
               public int num=10;
               public static int num=10;
               public final int num=10;
               public static final int num=10;
               public final static int num=10;//final 和static 顺序无所谓
        默认都是: public static final int num=10;
                少写的都会自动给你加上 (但是不能错写 比如绝对不能写 private)

     */
}

小结: 接口内以下两行代码是等价的

int NUM=10;

public static final int NUM=10;

1.4.2 构造方法

?	没有，因为接口主要是扩展功能的，而没有具体存在

那么实现类的构造方法默认的代码 super()执行的是什么呢? ctrl+鼠标点击查看一下 Object的构造方法
默认 extend Object 当然是 Object了
在这里插入图片描述

1.4.3 成员方法

?	只能是抽象方法 (JDK7及之前版本才成立)

?	默认修饰符：public abstract

?	关于接口中的方法，JDK8和JDK9中有一些新特性   (见下文)

public interface Inter {
    void study();//public权限 不是默认权限
    /*
    无论写: void study();  //此时不是默认权限 而还是public权限★★★
           public void study();
           abstract void study();
           public abstract void study();
     默认都是  public abstract void study();
           也就是说 默认修饰符是:public abstract   不写少写都会自动帮你加上
     */
}

小结: 接口内以下两行代码是等价的

List<T> findAll();

public abstract List<T> findAll();

由于重写方法的访问权限要大于等于(父类或者接口)被重新方法的访问权限，因此所有接口实现类对接口方法的实现(重写)，修饰符必须是public

演示代码小结:

public interface Inter {
    void study();   //== public abstract void study();
    int NUM=10;//== public staic final int NUM=10;
}

public class InterImpl implements Inter {
    @Override//接口抽象方法必然 public  此处不能小于public 所以也是public  
    public void study() {//当然abstract肯定没有了
        System.out.println("我是实现类方法");
        //num=20;//报错 提示final  接口变量默认final
        System.out.println(num);
    }

    InterImpl(){
                     super();
    }
}

public class Test1Interface {
    public static void main(String[] args) {
        InterImpl inter = new InterImpl();
        inter.study();
        System.out.println(Inter.num);//说明接口变量默认static
        //静态成员直接 接口名.num   或者 类名.num
    }
}

1.5 类和接口的关系（记忆）

类与类的关系

? 继承关系，只能单继承，但是可以多层继承
类与接口的关系

? 实现关系，可以单实现，也可以多实现，【还可以在继承一个类的同时实现多个接口】
接口与接口的关系

? 继承关系，可以单继承，也可以多继承

注意事项1 ：继承的同时+实现可能的冲突

继承类A与实现接口B 中有相同的带方法体的方法，优先执行类A的方法(亲爹嘛)

public class Fu {
    public void show(){
        System.out.println("Fu...show");
    }
}

public interface Inter {
    public default void show(){
        System.out.println("Inter...show");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.show();
    }
}

class Zi extends Fu implements Inter{
}

在这里插入图片描述

注意事项2 ：接口A多继承接口B、C时可能的冲突

接口A多继承接口B、C时，若B、C有相同的默认方法(带方法体的方法)，则接口必须重写该默认方法。【两个干爹的逻辑冲突了，则谁的逻辑都不要，要自己的】

public interface InterA {
    public default void show(){
        System.out.println("接口A default show");
    }
}

public interface InterB {
    public default void show(){
        System.out.println("接口B default show");
    }
}

注意写法，接口支持多继承

public interface InterC extends InterA,InterB {  //★ 注意这种写法 多继承
    @Override//没有此重写会报错的
    public default void show() {
        System.out.println("InterC自己重写的default show");
    }
}

public class Test {
    public static void main(String[] args) {
        InterImpl i=new InterImpl();
        i.show();
    }
}

class InterImpl implements InterC{
}

在这里插入图片描述

2.接口组成更新

JDK8版本后，java只对接口的成员方法进行了改进，也就是说接口的成员变量和构造方法都没变化

2.1接口组成更新概述【理解】

常量

public static final
抽象方法

public abstract
默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)

2.2接口中默认方法【应用】【jdk8新增带方法体的方法】关键字：default

在这里插入图片描述

其实或许每个人都想过，抽象类比接口灵活多了，因为抽象类可以有方法实现，可以有抽象方法，给抽象类加一个方法，给个空方法体，就可以让子类有需要地重写，不重写也不会报错。
.
然后对于接口，一旦修改了，比如加了一个方法定义(抽象方法)，那么所有接口的实现类都立刻报错，必须所有接口的实现类都重写了(实现了)接口新增方法后才恢复正常。实在是太暴力了 (适配器模式下也得修改适配器本身)
.
但是接口的使用已成规范(主要是多实现强于抽象类的单继承)于是在这种情况下JDK8就改进了接口，允许接口里有方法的实现(带方法体的方法)

在这里插入图片描述

格式

public default 返回值类型方法名(参数列表) { }
作用

解决接口升级的问题
范例
```
public default void show3() { 
}
```
注意事项
- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
- 接口中： public可以省略，default不能省略
- 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

1、直接继承接口的默认方法(已经有了实现的方法 )
在这里插入图片描述

2、也可以重写接口的default方法 (不能再有default关键字了)
在这里插入图片描述
3、有逻辑冲突，必须重写

两个干爹都有default方法，我继承的到底是谁的呢? 冲突了，都不用，强制重写，用自己的

在这里插入图片描述

2.3接口中静态方法【应用】【jdk8新增静态方法】关键字：static

格式 (和常规静态方法完全一样)

public static 返回值类型方法名(参数列表) { }
范例
```
public static void show() {
}
```
注意事项（和常规静态方法，唯一的两处不同）
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略

在这里插入图片描述

实现类名.静态方法名() 调用不行 ×
实现类对象.静态方法名() 调用不行 ×
只能接口名.静态方法名() 调用 √
因此 : 同时实现的两个接口有相同的静态方法，不会产生冲突，实现类根本“继承”不到任何接口的static方法

测试代码小结:

public interface InterA {
    public static void show(){
        System.out.println("接口A的静态方法");
    }
}

public interface InterB {
    public static void show(){
        System.out.println("B....静态方法");
    }
}

public class TestInterface {
    public static void main(String[] args) {
        InterA.show();
        InterImpl i=new InterImpl();
        //i.show();//报错 实现类对象调用不了接口静态方法
        //InterImpl.show();//同上相同报错
    }
}

class InterImpl implements InterA,InterB{

}

2.4接口中私有方法【应用】【jdk9新增声明格式和普通完全一样】

私有方法产生原因

Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性
定义格式
- 格式1 【和普通私有方法形式一样，格式并无新的特别特殊之处】
  
  private 返回值类型方法名(参数列表) { }
- 范例1
```
private void show() {  
}
```
- 格式2 【和普通私有静态方法形式一样，格式并无新的特别特殊之处】
  
  private static 返回值类型方法名(参数列表) { }
- 范例2
```
private static void method() {  
}
```
注意事项【老语法了】
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法

注意：jdk9环境下才可以测试
请添加图片描述

小结：接口的使用思路 ★

在这里插入图片描述

小知识

1、java单继承，不支持多继承
但是java支持多实现，一个类可以同时实现多个接口，重写所有抽象方法后才不用做抽象类)
2、实现类实现接口的方法，也称为重写(和子类继承父类重写非常像），从此处看其实也就是用接口机制变相实现了c++里的多继承【继承理解为亲爹，实现接口理解为认干爹亲爹只有一个但是干爹随便认】
3、class A implements I1,I2{…} I1和I2接口可以有完全一样的重复抽象方法(很像c里面的方法声明)，A里有一份实现即可，没有逻辑冲突语法错误啥的

1. 接口成员方法默认都是 public abstract (可少写不写不可错写)

亲测正确

public interface Inter {
    abstract void study();//public权限 不是默认权限
    /*
    无论写: void study();  //此时不是默认权限 而还是public权限★★★
           public void study();
           abstract void study();
           public abstract void study();
     默认都是  public abstract void study();
           也就是说 默认修饰符是:public abstract   不写少写都会自动帮你加上
     */
}

2.同理，接口中变量默认都是public static final (可少写不写不可错写)

public interface Inter {
    
    final static  int num=10;//以后都要大写NUM
    /*
        成员变量默认修饰符: public static final
        无论写: int num=10;
               final int num=10;
               static int num=10;
               static final num=10;
               public int num=10;
               public static int num=10;
               public final int num=10;
               public static final int num=10;
               public final static int num=10;//final 和static 顺序无所谓
        默认都是: public static final int num=10;
                少写的都会自动给你加上 (但是不能错写 比如绝对不能写 private)

     */
}