[code="java"]public class Cons
{
public static void main(String[] args)
{
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a2.show(b)); // ????????????
}
}
class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
public String show(C obj) {
return ("A and C");
}
}
class B extends A {
public String show(B obj) {
return ("B and B");
}
public String show(A obj) {
return ("B and A");
}
public String show(C obj) {
return ("B and C");
}
}
class C extends B {
}
class D extends B {
}
[/code]
[quote]意为 初始化时扫描全表，将所有方法放入某存储结构中（栈或队列等），调用方法时，再依次匹配，成功为止。差不多是这个意思？[/quote]
这个不是初始化？这个是编译器编译时，对java文件解析分析时做的事情。
不是在JVM中通过类加载器，加载类，创建类的实例。初始化。
[code="java"]A a2 = new B(); [/code]
这里把B的实例转换为A类型，在调用时首先匹配A中的
[code="java"]
public String show(A obj) {
return ("A and A");
}
[/code]
[code="java"]
这里B b = new B(); 是A的子类型，所以能够匹配成功，又由于你在子类改写了此方法，所以实际调用时 又调用了子类
public String show(A obj) {
return ("B and A");
}
[/code]
因而出现上面的结果。
你把
[code="java"] A a2 = new B();
[/code]
改为
[code="java"] B a2 = new B();
[/code]
就会出现："B and B"。
[quote]System.out.println(b.show(d));
答案是‘A and D’，为什么不是‘B and B’呢？ 谢谢！
[/quote]
这里B是继承A的先和A中的
[code="java"] public String show(D obj) {
return ("A and D");
} [/code]
匹配。在java中重载方法调用时遵循最相近匹配原则。
从父类向子类匹配。
[quote]从父类向子类匹配。
[/quote]这种说法不正确。
[code="java"] class A {
// public String show(D obj) {
// return ("A and D");
// }
public String show(A obj) {
return ("A and A");
}
public String show(C obj) {
return ("A and C");
}
}
[/code]
把A中的方法匹配就是：B and B
这实际是一个重载 和重写问题：
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
[code="java"]
class B extends A {
public String show(B obj) { //重载
return ("B and B");
}
public String show(A obj) { //重写
return ("B and A");
}
public String show(C obj) { //重写
return ("B and C");
}
}
[/code]
1.重载是编译时多态
2.重写是运行时多态
重载在编译时就能确定：
原则：
[quote]"
向上就近匹配原则
如果方法的参数表中的数据类型和调用时给出的参数类型不尽相同时会根据向上匹配的
就近原则。（类型就近向上转化匹配）
"
[/quote]
1.[code="java"]
class A {
// public String show(D obj) { //屏蔽掉show(D obj)
// return ("A and D");
// }
public String show(A obj) {
return ("A and A");
}
public String show(C obj) {
return ("A and C");
}
}
[/code]
第一次匹配： System.out.println(b.show(d));
失败。
向上转型：将d转换为父类B类型
再匹配就匹配了：
[code="java"] public String show(B obj) {
return ("B and B");
}
[/code]
2.不屏蔽A中方法show(D obj)
那么在第一次就匹配成功了。
3.问题：在重载方法匹配时先从父类重载方法开始匹配还是先从子类重载方法开始匹配？
这个是编译时应该有张methods table，按照方法在表中的索引依次匹配。这是个人见解，仅供参考。每次匹配时，需要全表扫描一次。