java8 接口之间继承与覆盖

Java8的接口里面允许定义静态方法，与默认方法，那么当一个子接口继承父接口时，那么接口中的默认方法与静态方法的继承与覆盖是怎么样的呢？

我们知道两个类有继承关系时，子类会继承父类的实例方法，静态方法，实例变量与静态变量，而且子类的实例方法、实例成员变量与父类的实例方法相同时（返回类型相同，参数列表相同，方法名也形同），实例成员变量相同时，子类会将父类的实例方法进行覆盖，对父类实例成员变量隐藏，但子类继承父类的静态方法或静态成员变量时，不会将父类的静态方法进行覆盖，只会对父类静态方法或静态成员变量进行隐藏！

public class Fu {
    static int  a = 5;  //父类静态成员变量
    int  b = 4;         //父类实例成员变量
    
    static void show(){
        System.out.println("父类静态方法");
    }

    void show1(){
        System.out.println("父类实例方法");
    }
}

class Zi extends Fu{

}

class DemoTest{
    public static void main(String [] args){
        Zi z = new Zi();
        System.out.println(z.a);
        System.out.println(z.b);
        z.show();
        z.show1();           

    }
}

输出:

5
4
父类静态方法
父类实例方法

可见子类会继承父类的静态成员，实例成员，静态方法，实例方法！

另外若将DemoTest类中  Zi z = new Zi();改为Fu z = new Zi();输出结果跟上面的结果一致！因为Zi类只是完全继承父类，此时多态也就没发挥出作用！

如将子类改写成：

class Zi extends Fu{
    int b = 40;
    static int a = 50;
    static void show(){
        System.out.println("子类的静态方法");
    }
    void show1(){
        System.out.println("子类覆盖父类的实例方法");
    }
}

同样DemoTest类中  Zi z = new Zi();改为Fu z = new Zi();输出结果为：

5
4
父类静态方法
子类覆盖父类的实例方法

可见静态方法，实例成员变量，静态成员变量都不存在多态。编译和运行都由等式左边决定，左边是什么类型就调用该类的属性和静态方法！而实例方法的覆盖，存在继承，即编译时看左边，运行时看右边！

接口的默认方法（接口的默认方法由default修饰，可以有方法体，不能与static关键字共存！）与抽象方法都可以像实例方法一样的继承，但是，当类或接口的超类型提供具有相同签名的多个默认方法时，Java编译器遵循以下继承规则来解决名称冲突：

1、实例方法优于接口默认方法。

public class Horse {
    public String identifyMyself() {
        return "I am a horse.";
    }
}

public interface Flyer {
    default public String identifyMyself() {
        return "I am able to fly.";
    }
}

public interface Mythical {
    default public String identifyMyself() {
        return "I am a mythical creature.";
    }
}

public class Pegasus extends Horse implements Flyer, Mythical {
    public static void main(String... args) {
        Pegasus myApp = new Pegasus();
        System.out.println(myApp.identifyMyself());
    }
}

运行得到如下结果：

I am a horse.（因为Pegasus类即继承了Horse类，又实现了Flyer，Mythical接口，他们中都存在一个相同标签的方法（返回类型相同，函数名形同，参数列表也相同），但由于实例方法优于接口默认方法，所以输出I am a horse）
2、父接口里面默认方法被别的接口覆盖过了，当一个类实现该接口和父接口或者（和另外的继承了父接口但没有覆盖父接口的默认方法的接口），会表现出覆盖以后的方法，如：

public interface Animal {
    default public String identifyMyself() {
        return "I am an animal.";
    }
}

interface EggLayer extends Animal {
    default public String identifyMyself() {
        return "I am able to lay eggs.";
    }
}

interface FireBreather extends Animal {
}

class Dragon implements EggLayer, Animal,FireBreather {
    public static void main (String... args) {
        Dragon myApp = new Dragon();
        System.out.println(myApp.identifyMyself());
    }
}

输出：
I am able to lay eggs.

注意千万不能实现两个或以上都覆盖了相同父接口默认方法的接口，否则会出现编译错误！

如下：

public interface Animal {
    default public String identifyMyself() {
        return "I am an animal.";
    }
}

interface EggLayer extends Animal {
    default public String identifyMyself() {
        return "I am able to lay eggs.";
    }
}

interface FireBreather extends Animal {
    default public String identifyMyself(){
        return "I am able to lay Fire.";
    }
}

class Dragon implements EggLayer,FireBreather {
    public static void main (String... args) {
        Dragon myApp = new Dragon();
        System.out.println(myApp.identifyMyself());
    }
}
上面代码出现编译错误！
如果不想出现编译错误，可借助super关键字，在实现类里指定继承的是哪个接口的默认函数，如下
class Dragon implements EggLayer, FireBreather {
    public String identifyMyself(){
        return FireBreather.super.identifyMyself();  //注意使用方法
    }
    public static void main (String... args) {
        Dragon myApp = new Dragon();
        System.out.println(myApp.identifyMyself());
    }
}
编译通过，输出：

        I am able to fire

另外：接口里面的静态方法不能被继承！