### [多继承](https://lingcoder.gitee.io/onjava8/#/book/10-Interfaces?id=%e5%a4%9a%e7%bb%a7%e6%89%bf) 多继承意味着一个类可能从多个父类型中继承特征和特性。 Java 在设计之初，C++ 的多继承机制饱受诟病。Java 过去是一种严格要求单继承的语言：只能继承自一个类（或抽象类），但可以实现任意多个接口。在 Java 8 之前，接口没有包袱——它只是方法外貌的描述。 多年后的现在，Java 通过默认方法具有了某种多继承的特性。结合带有默认方法的接口意味着结合了多个基类中的行为。因为接口中仍然不允许存在属性（只有静态属性，不适用），所以属性仍然只会来自单个基类或抽象类，也就是说，不会存在状态的多继承。正如下面这样： ~~~ // interfaces/MultipleInheritance.java import java.util.*; interface One { default void first() { System.out.println("first"); } } interface Two { default void second() { System.out.println("second"); } } interface Three { default void third() { System.out.println("third"); } } class MI implements One, Two, Three {} public class MultipleInheritance { public static void main(String[] args) { MI mi = new MI(); mi.first(); mi.second(); mi.third(); } } ~~~ 输出： ~~~ first second third ~~~ 现在我们做些在 Java 8 之前不可能完成的事：结合多个源的实现。只要基类方法中的方法名和参数列表不同，就能工作得很好，否则会得到编译器错误： ~~~ // interface/MICollision.java import java.util.*; interface Bob1 { default void bob() { System.out.println("Bob1::bob"); } } interface Bob2 { default void bob() { System.out.println("Bob2::bob"); } } // class Bob implements Bob1, Bob2 {} /* Produces: error: class Bob inherits unrelated defaults for bob() from types Bob1 and Bob2 class Bob implements Bob1, Bob2 {} ^ 1 error */ interface Sam1 { default void sam() { System.out.println("Sam1::sam"); } } interface Sam2 { default void sam(int i) { System.out.println(i * 2); } } // This works because the argument lists are distinct: class Sam implements Sam1, Sam2 {} interface Max1 { default void max() { System.out.println("Max1::max"); } } interface Max2 { default int max() { return 47; } } // class Max implements Max1, Max2 {} /* Produces: error: types Max2 and Max1 are imcompatible; both define max(), but with unrelated return types class Max implements Max1, Max2 {} ^ 1 error */ ~~~ **Sam**类中的两个`sam()`方法有相同的方法名但是签名不同——方法签名包括方法名和参数类型，编译器也是用它来区分方法。但是从**Max**类可看出，返回类型不是方法签名的一部分，因此不能用来区分方法。为了解决这个问题，需要覆写冲突的方法： ~~~ // interfaces/Jim.java import java.util.*; interface Jim1 { default void jim() { System.out.println("Jim1::jim"); } } interface Jim2 { default void jim() { System.out.println("Jim2::jim"); } } public class Jim implements Jim1, Jim2 { @Override public void jim() { Jim2.super.jim(); } public static void main(String[] args) { new Jim().jim(); } } ~~~ 输出： ~~~ Jim2::jim ~~~ 当然，你可以重定义`jim()`方法，但是也能像上例中那样使用**super**关键字选择基类实现中的一种。