javase -- 接口 | 刘民锴的个人博客

javase 学习笔记尚硅谷

学习笔记

发布日期: 2020-07-30

更新日期: 2021-01-12

文章字数: 1k

阅读时长: 4 分

阅读次数:

接口.

interface

java中类不支持多继承，使用接口实现多重继承的效果
开发中，类和接口是并列的两个结构
- interface
JDK7及以前：只能定义全局常量和抽象方法
- 全局常量：[public] [static] [final] type 常量名 = ...;
- 抽象方法：[public] [abstract] returnType 方法名();

JDK8：除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法

interface A{
    //静态方法 这个静态方法只能通过接口调用
    public static void method1(){
        System.out.println("接口中的静态方法");
    }
    //默认方法 权限修饰符 只能是public 或 缺省
    //1、可以重写默认方法（就是要省略default关键字）
    //2、如果实现类的父类，也有这个同名同参的方法，在实现类没有重写这个方法的情况下默认，使用父类的方法，不用接口中的默认方法 --> 类优先
    //3、如果有多个接口中默认方法同名同参 --> 爆红 ，那么必须重写该默认方法
    public default void method2(){
       System.out.println("接口中的默认方法"); 
    }

    public static void main(String[] args){
        A a = new A(){
          //匿名实现类  
        };     
        a.method2();//接口中的默认方法
        //a.method1();//爆红 接口 A 的静态方法只能以 A.method1 方式访问
        A.method1();//接口中的静态方法

    }
}

在实现类的非静态方法中调用这两种方法

之前通过实现类的对象调用这个默认方法，现在使用 接口.super.默认方法()调用

class B implements A{
    //用于调用接口中的方法
    public void method() {
        A.method1();//静态方法
        A.super.method2();//默认方法
    }
}

接口中不能定义构造器,不可实例化
java开发中，接口都是通过类实现
- class A implements I{}
若实现类，重写了接口所有的抽象方法，实现类才可以实例化
若实现类，没有完全重写接口所有的抽象方法，则这个实现类就是抽象类
类可以实现多个接口 —- 弥补了单继承的局限性
- class A extends B implements I1,I2...{}
接口存在继承，但是只能继承接口，且是多继承
- interface I extends I1,I2,...{}
接口的具体使用，体现多态性
- 接口 i = new 实现类();
接口，实际上可以看做是一种规范

也存在匿名实现类

public interface InterfaceTest {
    void run();
    public static void main(String[] args) {
        //接口的匿名实现类的匿名对象
        new InterfaceTest() {
            @Override
            public void run() {
                // TODO 自动生成的方法存根

            }
        };
    }
}

拓展.

（父类）属性与（接口）常量重名.

怎么调用

//1
interface A{
    int x = 1;
}
class B{
    int x = 2;
}
// 同时 继承B和实现A接口
public class C extends B implements A{
    int x = 3; // x = 3替换了 B.x 和 A.x 
    //但是如果注释掉 上面的语句，会导致 字段 x 有歧义(类B 和 接口A同级的)
    public void printX() {
        System.out.println(x); // C : 3
        System.out.println(super.x);// B : 2
        System.out.println(A.x);// A : 1
    }
    public static void main(String[] args){
          new C().printX();
    }
}

//2
interface A{
    int x = 1;
}
class B{
    int x = 2;
}
// 只实现 接口A 看 x 的值
public class C implements A{
    //int x = 3;
    public void printX() {
        System.out.println(x); // A : 3
        System.out.println(A.x);// A : 3
    }
    public static void main(String[] args){
          new C().printX();
    }
}

不同接口的抽象方法同名同参.

interface A{
    void run();
}

interface B{
    void run();
}

public class C implements A,B{
    @Override
    public void run(){
        // 一次重写 两个接口的方法
    }
}

父类和接口的方法同名同参.

interface A{
  void run();
}
class B{
   public void run() {
       System.out.println("父类方法");
   }
}
//不会报红 --> 上面的类优先原则 当接口和父类中方法同名同参 在子类没有重写父类的方法的情况下，优先使用父类的方法 这个方法 又相当于重写了接口中的抽象方法 所以没有爆红
public class C extends B implements A{

}