JAVA 编程五年多，我自以为已经熟谙 Overload 和 Override 背后的工作机制。当开始思考和记录下面这些案例时，才意识到我对它们的了解并不像自己想象的那样。为了让内容更有趣，下面会把它们列为一系列谜题，同时也提供了答案。如果你能不偷看做出所有答案，我会对你刮目相看。
1. 单一分派
给定下面两个类：
class Parent {
void print(String a) { log.info("Parent - String"); }
void print(Object a) { log.info("Parent - Object"); }
}
class Child extends Parent {
void print(String a) { log.info("Child - String"); }
void print(Object a) { log.info("Child - Object"); }
}
下面代码打印结果是什么？
String string = ""; Object stringObject = string; // 打印结果是什么? Child child = new Child(); child.print(string); child.print(stringObject); Parent parent = new Child(); parent.print(string); parent.print(stringObject);
答案：
child.print(string); // Prints: "Child - String" child.print(stringObject); // Prints: "Child - Object" parent.print(string); // Prints: "Child - String" parent.print(stringObject); // Prints: "Child - Object"
child.print(string) 和 parent.print(string) 是 Java 面向对象程序编程的教科书式示例。调用的方法取决于实例的“实际”类型，而非“声明”类型。也就是说，不论把变量定义为 Child 还是Parent，因为实际的实例类型是Child 都会调用 Child::print。
第二组输出结果更为棘手。stringObject 和 string 是完全相同的字符串，唯一的区别在于 string 声明为 String，而 stringObject 声明为 Object。Java 不支持双重分派（double-dispatch），因此在处理方法参数时，参数的“声明”类型优先于“实际”类型。即使参数“实际”类型是 String 还是会调用 print(Object)。
2. 隐式 Override
给定下面两个类：
class Parent {
void print(Object a) { log.info("Parent - Object"); }
}
class Child extends Parent {
void print(String a) { log.info("Child - String"); }
}
下面代码打印结果是什么？
String string = ""; Parent parent = new Child(); parent.print(string);
答案：
parent.print(string); // Prints: "Parent - Object"
实例的“实际”类型是 Child，声明的参数类型是 String。代码中确实有一个 Child::print(String)方法。前面的例子中 parent.print(string) 调用的正是这个方法，但这里不是。
检查子类 Override 前，Java 似乎要先选择调用哪个方法。这种情况下，实例声明的类型是Parent，而 Parent 中唯一匹配的方法是 Parent::print(Object)。接着，Java 会检查Parent::print(Object) 有没有潜在的 Override 方法，结果没有找到。因此，最后执行的就是这个方法。
3. 显式 Override
给定下面两个类：
class Parent {
void print(Object a) { log.info("Parent - Object!"); }
void print(String a) { throw new RuntimeException(); }
}
class Child extends Parent {
void print(String a) { log.info("Child - String!"); }
}
下面代码打印结果是什么？
String string = ""; Parent parent = new Child(); parent.print(string);
答案：
parent.print(string); // Prints: "Child - String!"
这个例子与前面的唯一区别在于添加了一个新的 Parent::print(String) 方法。实际上这个方法从来没有执行。如果运行，会抛出一个异常。然而，正是因为它的存在让 Java 执行了一个不同的方法。
运行时在分析 parent.print(String) 的时候，找到了一个可以匹配的 Parent::print(String) 方法，然后看到这个方法被 Child::print(String) 覆写。
通常认为如果不调用，只是添加一个新方法绝不会改变系统行为。上面的例子显然是另一种情况。
4. 带有歧义的参数
给定下面的类：
class Foo {
void print(Cloneable a) { log.info("I am cloneable!"); }
void print(Map a) { log.info("I am Map!"); }
}
下面代码打印结果是什么？
HashMap cloneableMap = new HashMap(); Cloneable cloneable = cloneableMap; Map map = cloneableMap; // 打印结果是什么? Foo foo = new Foo(); foo.print(map); foo.print(cloneable); foo.print(cloneableMap);
答案：
foo.print(map); // Prints: "I am Map!" foo.print(cloneable); // Prints: "I am cloneable!" foo.print(cloneableMap); // 编译失败
与单一分派类似，参数声明的类型优先于实际类型。如果传入参数有多个方法可以匹配，Java 会抛出编译错误，要求明确指定调用哪个方法。
5. 多重继承：接口
给定下面的接口：
interface Father {
default void print() { log.info("I am Father!"); }
}
interface Mother {
default void print() { log.info("I am Mother!"); }
}
class Child implements Father, Mother {}
下面代码打印结果是什么？
new Child().print();
与前面的例子类似，这个示例也不能编译通过。具体来说，由于 Father 和 Mother 中存在互相冲突的默认方法，Child 类无法编译通过。需要在 Child 类定义中明确指定 Child::print。
6. 多重继承：类与接口
给定下面的类和接口：
class ParentClass {
void print() { log.info("I am a class!"); }
}
interface ParentInterface {
default void print() { log.info("I am an interface!"); }
}
class Child extends ParentClass implements ParentInterface {}
下面代码打印结果是什么？
new Child().print();
答案：
new Child().print(); // Prints: "I am a class!"
说明：如果类和接口在继承时发生冲突，继承类优先。
7. Override 传递
给定下面的类：
class Parent {
void print() { foo(); }
void foo() { log.info("I am Parent!"); }
}
class Child extends Parent {
void foo() { log.info("I am Child!"); }
}
下面代码打印结果是什么？
new Child().print();
答案：
new Child().print(); // Prints: "I am Child!"
Override 对传递调用也有效。看过 Parent 定义的人可能认为 Parent::print 总是调用Parent::foo。但是如果该方法被 Override，那么 Parent::print 将调用 Override 版本的 foo()。
8. 私有 Override
给定下面的类：
class Parent {
void print() { foo(); }
private void foo() { log.info("I am Parent!"); }
}
class Child extends Parent {
void foo() { log.info("I am Child!"); }
}
下面代码打印结果是什么？
new Child().print();
答案：
new Child().print(); // Prints: "I am Parent!"
现在 Parent.foo() 声明变为 private，除此之外，这个示例与前面的例子完全相同。无论 foo() 在子类中是否实现了其它版本，也不管调用 print() 的实例类型如何，当 Parent.print() 调用 foo()时，foo() 都会硬编码为 Parent.foo()。
通常认为，把一个方法从 public 改为 private，只要编译成功，仅仅是一次重构。上面的例子证明这种想法是错的：即使编译成功，系统行为也可能出现意料之外的变化。
解决方法，可以为方法加上 @Override 注解。一旦改变基类方法的可见性，就会引起编译错误。
9. 静态 Override
给定下面的类：
class Parent {
static void print() { log.info("I am Parent!"); }
}
class Child extends Parent {
static void print() { log.info("I am Child!"); }
}
下面代码打印结果是什么？
Child child = new Child(); Parent parent = child; parent.print(); child.print();
答案：
parent.print(); // Prints: "I am Parent!" child.print(); // Prints: "I am Child!"
Java 不支持静态方法 Override。如果父类和子类中定义了相同的静态方法，仅根据声明类型决定调用哪个方法，不考虑实例类型。
这与非静态方法的处理完全相反：非静态方法会依据实例类型决定调用哪个方法，忽略声明类型。因此，把方法改为静态方法或者反向操作需要格外小心。即使没有编译错误，系统行为也可能出现意料之外的变化。
这也是给方法加上 @Override 注解的另一个重要原因。上面的例子中，如果为 Child::print 加上注解会报告一个编译错误：静态方法不能 Override。
不仅如此，最佳实践也要求不使用实例调用静态方法：不仅可能导致类似上面的意外结果，在重构出现问题时也无法告警。示例中这样调用 static 方法时，像 Intellij 这样的 IDE 会给出警告，最好给予足够的重视并处理。
10. 静态链接
给定下面的类：
class Parent {
void print() { staticMethod(); instanceMethod(); }
static void staticMethod() { log.info("Parent::staticMethod"); }
void instanceMethod() { log.info("Parent::instanceMethod"); }
}
class Child extends Parent {
static void staticMethod() { log.info("Child::staticMethod"); }
void instanceMethod() { log.info("Child::instanceMethod"); }
}
下面代码打印结果是什么？
Child child = new Child(); child.print();
答案：
Parent::staticMethod Child::instanceMethod
这个例子组合了之前讨论的各个主题。即使调用方法在父类中，Override 也会生效。然而，对于静态方法，即使变量声明的类型是 Child 仍然调用的是 Parent::staticMethod。
11. 总结
如果说有什么值得注意的话，那就是处理继承非常棘手，而且很容易出错。如果试图在继承上耍小聪明，总有一天会吃苦头。还是建议循规蹈矩，用最佳实践来保护自己：
