为什么接口的静态方法不能被继承

我解释一下我的意思:

例如,下面有一个父类和一个子类,父类中有一个普通方法和一个静态方法,子类继承了父类,在main方法中new子类,使用子类对象可以调用父类中的face()和gender()方法;

class Father {


    void face() {                       //普通方法
        System.out.println("爸爸的脸");
    }

    static void gender() {              //静态方法
        System.out.println("是一个男生");
    }
}


 class Son extends Father {

}

 class test01 {
    public static void main(String[] args) {
        Son son = new Son();
        son.face();
        son.gender();
    }
}

打印结果如下:

 

但当一个爸爸的接口中有一个默认方法face()和静态方法gender()时,同样一个类Son去实现这个接口,而在main方法中,新new的Son不可以调用gender()方法,编译会报错;

public interface FatherService {
    
    
    default void face() {                  //默认方法
        System.out.println("爸爸的脸");
    }
    
    static void gender() {                 //静态方法
        System.out.println("是一个男生");
    }
}

class Son implements FatherService {
}
 
class test01 {
    public static void main(String[] args) {
        Son son = new Son();
        son.face();
        Son.gender();                 //编译报错
    }
}

  以下是我的理解:

       因为如果可以继承接口中的静态方法,那么当有俩个接口同时被一个类实现,且这俩个接口有一个相同的静态方法,那这个类就不知道该去实现谁的了,只能去重写,就像接口的默认方法一样;但静态的又不可以被改变,是无法重写的,所以接口的静态方法不会被继承;

因为gender()是接口FatherService的静态成员,而不是类Son的静态成员;

       也有人说那父类的静态方法在子类中怎么就能被继承,因为在类中只有单继承,不会继承多个类;再加一句,子类中重写父类的静态方法其实是新开辟了一个空间,并没有重写这么一说;

以下举个例子:

        现在有一个爸爸的接口和一个妈妈的接口,都有一个默认方法face()和一个静态方法gender();

类Son同时去实现这俩个接口,而这时,俩个接口有相同的默认方法face(),类Son不知道继承哪个,就需要重写了,而静态方法同样还是会编译报错;只能使用接口直接调用;

interface FatherService {

    default void face() {                  //默认方法
        System.out.println("爸爸的脸");
    }

    static void gender() {                 //静态方法
        System.out.println("是一个男生");
    }
}

interface MotherService {

    default void face() {                 //默认方法
        System.out.println("妈妈的脸");
    }

    static void gender() {               //静态方法
        System.out.println("是一个女生");
    }
}

class Son implements FatherService, MotherService {
    //俩个接口有相同的默认方法face(),需要重写;
    @Override
    public void face() {
        System.out.println("结合了爸爸妈妈的脸");
    }
}


class test01 {
    public static void main(String[] args) {
        Son son = new Son();
        son.face();
        //Son.gender();                 //编译报错
        FatherService.gender();
        MotherService.gender();
    }
}

打印结果如下:

 最后,当一个子类继承了一个父类并实现了一个接口,而父类有一个face()方法,接口中有一个默认方法face();那么子类会优先调用父类的face()方法;但是常量会编译报错;

public interface FatherService {
    static int AGE = 30;                       //常量

    default void face() {                      //默认方法
        System.out.println("接口的face()方法");
    }
}

class Father {
     static int AGE = 25;                      //常量

    public void face() {                       //默认方法
        System.out.println("父类的face()方法");
    }
}

class Son extends Father implements FatherService {

}

class test01 {
    public static void main(String[] args) {
        Son son = new Son();
        son.face();
        //System.out.println(Son.AGE);//编译错误
    }
}

打印结果: