我们先来看一下下面的例子：
|
package demo.jvm.test8? public /**
*
*/ static } static } static } public System.out.println("hello,guy！")? } public System.out.println("hello,gentleman！")? } public System.out.println("hello,lady！")? } public Human man = new Human woman = new Demo2 sr = new sr.sayHello(man)? sr.sayHello(woman)? } |
|
} 结果： hello,guy！ hello,guy！ package import public /**
*
*/ static } static } static } public System.out.println("hello,guy！")? } public System.out.println("hello,gentleman！")? } public System.out.println("hello,lady！")? } public Human man = new |
Human woman = new
Woman()?
Demo2 sr = new
Demo2()?
sr.sayHello((Man)man)?
sr.sayHello((Woman)woman)?
}
}
结果：
hello,gentleman！
hello,lady！
注意在这里之和传入的变量有关系的。
重载为什么为什么都是父类的呢？
我们来看一下下面的解释：
我们把上面代码中的"Human"称为变量的静态类型（Static Type），或者叫做的外观类型（Apparent Type），后面的"Man"则称为变量的实际类型（Actual Type），静态类型和实际类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的；而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么。重载是编译器就决定了的。
解释了这两个概念，再回到代码清单8-6的样例代码中。main（）里面的两次sayHello（）方法调用，在方法接收者已经确定是对象"sr"的前提下，使用哪个重载版本，就完全取决于传入参数的数量和数据类型。代码中刻意地定义了两个静态类型相同但实际类型不同的变量，但虚拟机（准确地说是编译器）在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译期可知的，因此，在编译阶段，Javac编译器会根据参数的静态类型决定使用哪个重载版本，所以选择了sayHello（Human）作为调用目标，并把这个方法的符号引用写到main（）方法里的两条invokevirtual指令的参数中。
所有依赖静态类型来定位方法执行版本的分派动作称为静态分派。静态分派的典型应用是方法重载。静态分派发生在编译阶段，因此确定静态分派的动作实际上不是由虚拟机来执行的。另外，编译器虽然能确定出方法的重载版本，但在很多情况下这个重载版本并不是"唯一的"，往往只能确定一个"更加合适的"版本。这种模糊的结论在由0和1构成的计算机世界中算是比较"稀罕"的事情，产生这种模糊结论的主要原因是字面量不需要定义，所以字面量没有显式的静态类型，它的静态类型只能通过语言上的规则去理解和推断。代码清单
8-7演示了何为"更加合适的"版本。
|
package demo.jvm.test8? import public public } public System.out.println("hello int")? } public System.out.println("hello long")? } public } public System.out.println("hello char")? } public } public } public |
|
sayHello(‘a‘)? } } 结果是： hello char 这很好理解，‘a‘是一个char类型的数据，自然会寻找参数类型为char的重载方法，如果注释掉sayHello（char arg）方法，那输出会变为： package import public public } public System.out.println("hello int")? } public System.out.println("hello long")? } public } public } public } |
|
public static void main(String[] args) { sayHello(‘a‘)? } } 结果是： hello int 这时发生了一次自动类型转换，‘a‘除了可以代表一个字符串，还可以代表数字97（字符‘a‘的Unicode数值为十进制数字97），因此参数类型为int的重载也是合适的。我们继续注释掉sayHello（int arg）方法，那输出会变为： package import public public } public System.out.println("hello long")? } public } public } public } public sayHello(‘a‘)? |
|
} } 结果是：hello long 这时发生了两次自动类型转换，‘a‘转型为整数97之后，进一步转型为长整数97L，匹配了参数类型为long的重载。笔者在代码中没有写其他的类型如float、double等的重载，不过实际上自动转型还能继续发生多次，按照char-＞int-＞long-＞float-＞double的顺序转型进行匹配。但不会匹配到byte和short类型的重载，因为char到byte或short的转型是不安全的。我们继 续注释掉sayHello（long arg）方法，那输出会变为： package import public public } public } public } public } public sayHello(‘a‘)? } |
|
} 结果是： hello Character 这时发生了一次自动装箱，‘a‘被包装为它的封装类型java.lang.Character，所以匹配到了参数类型为Character的重载，继续注释掉sayHello（Character arg）方法，那输出会变为： package import public public } public } public } public sayHello(‘a‘)? } } 结果是： hello Serializable 这个输出可能会让人感觉摸不着头脑，一个字符或数字与序列化有什么关系？出现hello Serializable，是因为java.lang.Serializable是java.lang.Character类实现的一个接口，当自动装箱之后发现还是找不到装箱类，但是找到了装箱类实现了的接口类型，所以紧接着又发生一次 自动转型。char可以转型成int，但是Character是绝对不会转型为Integer的，它只能安全地转 |
|
型为它实现的接口或父类。Character还实现了另外一个接口java.lang.Comparable＜ Character ＞，如果同时出现两个参数分别为Serializable和Comparable＜Character＞的重载方法，那它们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型，会提示类型模糊，拒绝编译。程序必须在调用时显式地指定字面量的静态类型，如：sayHello（（Comparable＜ Character＞）‘a‘），才能编译通过。下面继续注释掉sayHello（Serializable arg）方法，输出会变为： package public public } public } public sayHello(‘a‘)? } } 结果是：hello Object 这时是char装箱后转型为父类了，如果有多个父类，那将在继承关系中从下往上开始搜索，越接近上层的优先级越低。即使方法调用传入的参数值为null时，这个规则仍然适用。我们把sayHello（Object arg）也注释掉，输出将会变为： package public public } |
|
public static void main(String[] args) { sayHello(‘a‘)? } } 结果是： hello char…… 7个重载方法已经被注释得只剩一个了，可见变长参数的重载优先级是最低的，这时候 字符‘a‘被当做了一个数组元素。笔者使用的是char类型的变长参数，读者在验证时还可以选 择int类型、Character类型、Object类型等的变长参数重载来把上面的过程重新演示一遍。但 要注意的是，有一些在单个参数中能成立的自动转型，如char转型为int，在变长参数中是不成立的 |
原文地址：https://www.cnblogs.com/qingruihappy/p/9691683.html