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("子類覆蓋父類的例項方法");
    }
}

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());
    }
}

注意千萬不能實現兩個或以上都覆蓋了相同父介面預設方法的介面，否則會出現編譯錯誤！

如下：

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());
    }
}