Jvm(65),方法调用----静态分派调用

Posted qingruihappy

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Jvm(65),方法调用----静态分派调用相关的知识,希望对你有一定的参考价值。

我们先来看一下下面的例子:

package demo.jvm.test8?

public class Demo2 {

/**

  • 方法静态分派演示

*

  • @author zzm

*/

static abstract class Human {

}

 

static class Man extends Human {

}

 

static class Woman extends Human {

}

 

public void sayHello(Human guy) {

System.out.println("hello,guy")?

}

 

public void sayHello(Man guy) {

System.out.println("hello,gentleman")?

}

 

public void sayHello(Woman guy) {

System.out.println("hello,lady")?

}

public static void main(String[] args) {

Human man = new Man()?

Human woman = new Woman()?

Demo2 sr = new Demo2()?

sr.sayHello(man)?

sr.sayHello(woman)?

 

}

 

}

结果:

hello,guyhello,guy

package demo.jvm.test8?

import demo.jvm.test8.Demo6.Man? import demo.jvm.test8.Demo6.Woman?

 

public class Demo2 {

/**

  • 方法静态分派演示

*

  • @author zzm

*/

static abstract class Human {

}

 

static class Man extends Human {

}

 

static class Woman extends Human {

}

 

public void sayHello(Human guy) {

System.out.println("hello,guy")?

}

 

public void sayHello(Man guy) {

System.out.println("hello,gentleman")?

}

 

public void sayHello(Woman guy) {

System.out.println("hello,lady")?

}

public static void main(String[] args) {

Human man = new Man()?

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 java.io.Serializable?

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

public static void sayHello(int arg) {

System.out.println("hello int")?

}

 

public static void sayHello(long arg) {

System.out.println("hello long")?

}

 

public static void sayHello(Character arg) { System.out.println("hello Character")?

}

 

public static void sayHello(char arg) {

System.out.println("hello char")?

}

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

public static void sayHello(Serializable arg) { System.out.println("hello Serializable")?

}

 

public static void main(String[] args) {

 

sayHello(‘a‘)?

}

}

结果是:

hello char

这很好理解,‘a‘是一个char类型的数据,自然会寻找参数类型为char的重载方法,如果注释掉sayHellochar arg)方法,那输出会变为:

package demo.jvm.test8?

import java.io.Serializable?

 

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

public static void sayHello(int arg) {

System.out.println("hello int")?

}

 

public static void sayHello(long arg) {

System.out.println("hello long")?

}

 

public static void sayHello(Character arg) { System.out.println("hello Character")?

}

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

public static void sayHello(Serializable arg) { System.out.println("hello Serializable")?

}

 

 

public static void main(String[] args) {

sayHello(‘a‘)?

}

}

结果是:

hello int

这时发生了一次自动类型转换,‘a‘除了可以代表一个字符串,还可以代表数字97(字符‘a‘Unicode数值为十进制数字97),因此参数类型为int的重载也是合适的。我们继续注释掉sayHelloint arg)方法,那输出会变为:

package demo.jvm.test8?

import java.io.Serializable?

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

public static void sayHello(long arg) {

System.out.println("hello long")?

}

 

public static void sayHello(Character arg) { System.out.println("hello Character")?

}

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

public static void sayHello(Serializable arg) { System.out.println("hello Serializable")?

}

 

public static void main(String[] args) {

sayHello(‘a‘)?

 

} }

结果是:hello long

这时发生了两次自动类型转换,‘a‘转型为整数97之后,进一步转型为长整数97L,匹配了参数类型为long的重载。笔者在代码中没有写其他的类型如floatdouble等的重载,不过实际上自动转型还能继续发生多次,按照char-int-long-float-double的顺序转型进行匹配。但不会匹配到byteshort类型的重载,因为charbyteshort的转型是不安全的。我们继

续注释掉sayHellolong arg)方法,那输出会变为:

package demo.jvm.test8?

 

import java.io.Serializable?

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

 

public static void sayHello(Character arg) { System.out.println("hello Character")?

}

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

public static void sayHello(Serializable arg) { System.out.println("hello Serializable")?

}

 

public static void main(String[] args) {

sayHello(‘a‘)?

}

 

}

结果是:

hello Character

这时发生了一次自动装箱,‘a‘被包装为它的封装类型java.lang.Character,所以匹配到了参数类型为Character的重载,继续注释掉sayHelloCharacter arg)方法,那输出会变为:

package demo.jvm.test8?

 

import java.io.Serializable?

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

public static void sayHello(Serializable arg) { System.out.println("hello Serializable")?

}

 

public static void main(String[] args) {

sayHello(‘a‘)?

}

}

结果是:

hello Serializable

这个输出可能会让人感觉摸不着头脑,一个字符或数字与序列化有什么关系?出现hello

Serializable,是因为java.lang.Serializablejava.lang.Character类实现的一个接口,当自动装箱之后发现还是找不到装箱类,但是找到了装箱类实现了的接口类型,所以紧接着又发生一次

自动转型。char可以转型成int,但是Character是绝对不会转型为Integer的,它只能安全地转

 

型为它实现的接口或父类。Character还实现了另外一个接口java.lang.Comparable

Character

>,如果同时出现两个参数分别为SerializableComparableCharacter>的重载方法,那它们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型,会提示类型模糊,拒绝编译。程序必须在调用时显式地指定字面量的静态类型,如:sayHello((ComparableCharacter>)‘a‘),才能编译通过。下面继续注释掉sayHelloSerializable arg)方法,输出会变为:

package demo.jvm.test8?

public class Demo3 {

public static void sayHello(Object arg) { System.out.println("hello Object")?

}

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

 

public static void main(String[] args) {

sayHello(‘a‘)?

} }

结果是:hello Object

这时是char装箱后转型为父类了,如果有多个父类,那将在继承关系中从下往上开始搜索,越接近上层的优先级越低。即使方法调用传入的参数值为null时,这个规则仍然适用。我们把sayHelloObject arg)也注释掉,输出将会变为:

package demo.jvm.test8?

public class Demo3 {

 

public static void sayHello(char...arg){ System.out.println("hello char……")?

}

 

 

 

public static void main(String[] args) {

sayHello(‘a‘)?

}

}

结果是:

hello char……

7个重载方法已经被注释得只剩一个了,可见变长参数的重载优先级是最低的,这时候

字符‘a‘被当做了一个数组元素。笔者使用的是char类型的变长参数,读者在验证时还可以选

int类型、Character类型、Object类型等的变长参数重载来把上面的过程重新演示一遍。但

要注意的是,有一些在单个参数中能成立的自动转型,如char转型为int,在变长参数中是不成立的

以上是关于Jvm(65),方法调用----静态分派调用的主要内容,如果未能解决你的问题,请参考以下文章

JVM学习笔记--方法调用之静态分配和动态分配

JVM之字节码执行引擎

Jvm(66),方法调用----动态分派调用

深入理解Java虚拟机——方法调用(静态分派调用)

深入理解Java虚拟机——方法调用(静态分派调用)

Jvm(67),方法调用----单分派与多分派