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

文章目录

• • 1.接口
  • • 1.1 引入
    • 1.2 接口的概述（理解）
    • 1.3 接口的特点（记忆）
    • 1.4 接口的成员特点（记忆）
    • • 1.4.1 成员变量
      • 1.4.2 构造方法
      • 1.4.3 成员方法
    • 1.5 类和接口的关系（记忆）
    • • 注意事项1 ：继承的同时+实现 可能的冲突
      • 注意事项2 ：接口A多继承接口B、C时可能的冲突
  • 2.接口组成更新
  • • 2.1接口组成更新概述【理解】
    • 2.2接口中默认方法【应用】 【jdk8新增带方法体的方法】 关键字：default
    • 2.3接口中静态方法【应用】【jdk8新增静态方法】 关键字：static
    • 2.4接口中私有方法【应用】【jdk9新增 声明格式和普通完全一样】
    • 小结：接口的使用思路 ★
• 小知识
• • 1. 接口成员方法默认都是 public abstract (可少写不写 不可错写)
  • 2.同理，接口中变量默认都是public static final (可少写不写 不可错写)

1.接口 1.1 引入

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

接口存在的两个重要意义

1. 规则的定义
2. 程序的拓展性

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
    
}

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

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权限 不是默认权限
    
}

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

List findAll();

public abstract List 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权限 不是默认权限
    
}

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

public interface Inter {
    
    final static  int num=10;//以后都要大写NUM
    
}

注意事项:

静态成员直接 类名.num；类名.study() 或 接口名.num ； 接口名.study() ; 从来都不需要new关键字