Jvm（65），方法调用----静态分派调用

Posted 2021-01-08 qingruihappy

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

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,guy！ hello,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的重载方法，如果注释掉sayHello（char 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的重载也是合适的。我们继续注释掉sayHello（int 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的重载。笔者在代码中没有写其他的类型如float、double等的重载，不过实际上自动转型还能继续发生多次，按照char-＞int-＞long-＞float-＞double的顺序转型进行匹配。但不会匹配到byte和short类型的重载，因为char到byte或short的转型是不安全的。我们继 续注释掉sayHello（long 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的重载，继续注释掉sayHello（Character 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.Serializable是java.lang.Character类实现的一个接口，当自动装箱之后发现还是找不到装箱类，但是找到了装箱类实现了的接口类型，所以紧接着又发生一次 自动转型。char可以转型成int，但是Character是绝对不会转型为Integer的，它只能安全地转

 

型为它实现的接口或父类。Character还实现了另外一个接口java.lang.Comparable＜ Character ＞，如果同时出现两个参数分别为Serializable和Comparable＜Character＞的重载方法，那它们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型，会提示类型模糊，拒绝编译。程序必须在调用时显式地指定字面量的静态类型，如：sayHello（（Comparable＜ Character＞）‘a‘），才能编译通过。下面继续注释掉sayHello（Serializable 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时，这个规则仍然适用。我们把sayHello（Object 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，在变长参数中是不成立的