106. Java 继承 - 接口方法的继承与冲突解决

106. Java 继承 - 接口方法的继承与冲突解决

在 Java 中，接口可以定义默认方法（default）和抽象方法（没有实现的方法）。类可以实现接口，并继承其默认方法。继承过程中，接口中的默认方法和抽象方法会被子类继承，但在某些情况下，如果多个接口定义了同名的默认方法，则需要解决冲突。

继承默认方法与抽象方法

默认方法和抽象方法在接口中就像实例方法一样被继承。默认方法带有实现，而抽象方法则没有实现。当一个类实现多个接口时，如果这些接口中有相同签名的默认方法，则会出现冲突，编译器会根据以下规则来决定调用哪个方法：

1. 实例方法优先于接口中的默认方法：如果子类或实现类提供了一个实例方法，它将覆盖接口中的默认方法。
2. 接口方法冲突时的解决：当类或接口的超类型提供具有相同签名的多个默认方法时，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());
    }
}

在上面的代码中，类 Pegasus 继承了类 Horse 和接口 Flyer、Mythical。尽管 Flyer 和 Mythical 接口都有 identifyMyself() 方法的默认实现，但由于 Horse 类提供了该方法的实例实现，Pegasus 使用了 Horse 中的 identifyMyself() 方法，输出结果是：

I am a horse.

示例 2：接口方法的冲突解决

当多个接口提供相同签名的默认方法时，Java 编译器将遵循一定的规则来解决冲突。下面的示例展示了一个接口冲突的解决：

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

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

public interface FireBreather extends Animal { }

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

在这个示例中，EggLayer 和 FireBreather 都继承了 Animal 接口，其中 EggLayer 重写了 identifyMyself() 方法。由于 Dragon 类实现了这两个接口，最终 Dragon 使用了 EggLayer 中的 identifyMyself() 方法，输出：

I am able to lay eggs.

当接口的默认方法发生冲突时

如果两个或多个接口的默认方法发生冲突，或者默认方法与抽象方法冲突，编译器会产生编译时错误，要求显式覆盖该方法。例如：

public interface OperateCar {
    default public int startEngine(EncryptedKey key) {
        // 实现细节
    }
}

public interface FlyCar {
    default public int startEngine(EncryptedKey key) {
        // 实现细节
    }
}

public class FlyingCar implements OperateCar, FlyCar {
    public int startEngine(EncryptedKey key) {
        // 必须重写该方法
        FlyCar.super.startEngine(key);  // 调用 FlyCar 中的默认实现
        OperateCar.super.startEngine(key);  // 调用 OperateCar 中的默认实现
    }
}

在此示例中，FlyingCar 类实现了两个接口 OperateCar 和 FlyCar，它们都定义了名为 startEngine() 的默认方法。由于冲突，FlyingCar 必须显式重写该方法，并使用 super 关键字调用两个接口中的默认实现。

从类继承的实例方法覆盖抽象接口方法

如果一个类继承了实例方法并且该方法覆盖了接口中的同名抽象方法，那么该类将使用实例方法的实现：

public interface Mammal {
    String identifyMyself();
}

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

public class Mustang extends Horse implements Mammal {
    public static void main(String... args) {
        Mustang myApp = new Mustang();
        System.out.println(myApp.identifyMyself());
    }
}

在上面的代码中，Mustang 类继承了 Horse 类，并实现了 Mammal 接口。由于 Horse 类已经提供了 identifyMyself() 的实例方法实现，Mustang 将调用 Horse 中的实现，而不是接口 Mammal 中的抽象方法。输出结果为：

I am a horse.

静态方法永远不会被继承

需要注意的是，接口中的静态方法永远不会被继承，即使类实现了接口，也无法直接访问接口中的静态方法。静态方法只能通过接口名称调用。

---

总结

• 实例方法优先于接口中的默认方法。当类提供了自己的实例方法时，接口的默认方法会被覆盖。
• 默认方法冲突时，编译器会根据继承规则选择合适的方法，若无法解决冲突，编译器会提示错误，要求显式重写。
• 接口中的静态方法永远不会被继承，只能通过接口名称来调用。

通过这些示例和解释，学员可以更好地理解接口方法在继承、覆盖和冲突时的行为，掌握如何使用 super 关键字解决冲突，进而应用到实际的开发中。