JVM学习之:浅谈方法调用以及Override/Overload的原理


提到方法调用,我想大多数人的第一反应就是执行一个方法呗,其实在虚拟机的眼里方法调用只是确定他要调用哪个方法而已,和方法的执行还是有比较大的区别的.任何一个层序的运行都离不开方法的调用以及方法的执行,但是在JVM学习之:虚拟机中的运行时栈帧总结(二)提到过,在Class文件的编译过程中不包括传统的连接步骤(连接:把符号引用转化为可以直接找到方法体的直接引用),但是正是因为这点也给java带来了更大的灵活性,因为不同的实现可能会在不同的阶段对符号引用进行转化,下面是对几种常见的方法调用类型进行描述


解析:

JVM学习之:虚拟机中的运行时栈帧总结中提到了,如果符号引用是在类加载阶段或者第一次使用的时候转化为直接应用,那么这种转换成为静态解析,那么什么样的方法会在这个阶段进行转换了?虚拟机规范提到,只有在真正运行之前就可以确定调用版本的,并且在运行时是不可变的方法,简单的讲,也就是不能被覆盖.不能被改变,不能被重载的方法,其实也就是static方法,private方法,final方法,<init>构造器,父类方法,这几种方法都是适合在类加载解析阶段讲符号引用转换为直接引用的,对这写种类方法的调用也被称为解析.除了这些方法的其他方法也被称作为虚方法()

前面提到了几种方法的调用,虚拟机也提供了对应的字节码指令,分别是:

invokestatic:调用静态方法

invokespecial:调用构造器方法,私有方法以及父类方法

invokevirtual:调用虚方法以及final方法(虽然用invokevirtual调用,可是因为final方法的不可覆盖性,因此也是非虚方法)

invokeinterface:调用接口方法,会在运行时再确定一个具体的实现方法


下面通过一个演示类的反编译结果来对上面的字节码指令进行验证:

package com.eric.jvm.executor;

/**
 * 通过反编译字节码来验证 
 * invokestatic:调用静态方法 
 * invokespecial:调用构造器方法,私有方法以及父类方法
 * invokevirtual:调用虚方法以及final方法(虽然用invokevirtual调用,可是因为final方法的不可覆盖性,因此也是非虚方法)
 * invokeinterface:调用接口方法,会在运行时再确定一个具体的实现方法
 * 
 * 
 * javap -verbose com.eric.jvm.executor.InvokeCommandExecutor
 * 
 * @author Eric
 * 
 */
public class InvokeCommandExecutor {
	
	
	public static void main(String[] args) {
		//invokestatic
		SubInvoker.invokeStatic();
		//invokespecial,
		SubInvoker si=new SubInvoker();
		//invokevirtual
		si.invokeVirtual();
		//invokeinterface
		si.invokeInterface();
	}
	
}

class SubInvoker implements IExecutor{
	public static void invokeStatic(){
		System.out.println("invokestatic was execute");
	}
	public SubInvoker(){
		System.out.println("invokespecial was execute in construct");
	};
	public void invokeVirtual(){
		System.out.println("invokevirtual was execute");
	}
	@Override
    public void invokeInterface() {
		System.out.println("invokeinterface was execute");
    }
}

interface IExecutor{
	public void invokeInterface();
}

反编译后的相关的指令片段:对应main中的方法调用顺序





分派:

众所周知,面向对象的三个特点是:"继承,封装,多态",其中多态又包括覆盖和重载,本节提到的分派就是覆盖和重载的底层实现基础.那么让我们来看看什么是分派?分派和解析属于同一个范畴的概念,都是方法调用的类型而已,只是分派比解析要稍微的复杂一点,分派的符号应用可以再类加载阶段进行转换,也可以再运行时进行转换,而且根据宗量也可能存在单个宗量以及多个宗量,下面将分别对其种类进行说明:


静态分派(Overload):

静态分派可以认为是java可是实现overload的最根本的原因,首先让我们来看一个关于overload的例子(在写这篇文章之间我还是没能猜出正确的输出,正是可悲啊...)

package com.eric.jvm.executor;

public class MethodOverloadResolution {
	public static void main(String[] args) {
		Human human = new Human();
		Human man = new Man();
		Human women = new Women();
		MethodOverloadResolution mor = new MethodOverloadResolution();
		mor.hello(human);
		mor.hello(man);
		mor.hello(women);
		//静态类型发生变化
		mor.hello((Man)man);
		mor.hello((Women)women);
	}
	
	public void hello(Human human) {
		System.out.println("Human say hello");
	}
	
	public void hello(Man human) {
		
		System.out.println("Man say hello");
	}
	
	public static void hello(Women human) {
		
		System.out.println("Women say hello");
	}
	
}

class Human {}

class Man extends Human {}

class Women extends Human {}

其输出的结果是

Human say hello
Human say hello
Human say hello
Man say hello
Women say hello

我想经常面试的人可以很顺利的猜到正确的输出结果,可是如果要是问一下到底为什么会这样可能很多人就答不出来了,下面我来对为什么会输出上面这样的结果来解释一下,

Human man = new Man();

首先看看两个比较重要的概念,Human是静态类型,Man是动态类型,静态类型是在编译期间确定的,而且虚拟机的重载依据是根据静态类型类确定的,所以在编译阶段,虚拟机已经决定好了要是用哪个版本的方法这也是输出3个Human say hello的原因.

依赖静态类型类确定方法版本的分派动作方式称为静态分派


关于静态分派还有一点比较重要的就是,在选择方法版本的时候是选择一个"最适合的",下面通过一个例子来看看到底什么是"最适合的":

import java.io.Serializable;

public class MethodOverloadDemonstrate {
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		MethodOverloadDemonstrate demonstrate=new MethodOverloadDemonstrate();
		demonstrate.overLoad('c');
	}
	
	public void overLoad(char c){System.out.println("char");}
	public void overLoad(int c){System.out.println("int");}
	public void overLoad(long c){System.out.println("long");}
	public void overLoad(float c){System.out.println("float");}
	public void overLoad(double c){System.out.println("double");}
	public void overLoad(Character c){System.out.println("Character");}
	public void overLoad(Serializable c){System.out.println("Serializable");}
	public void overLoad(Object... c){System.out.println("Object...");}
	public void overLoad(Object c){System.out.println("Object");}
	public void overLoad(Integer c){System.out.println("Integer");}
	public void overLoad(Comparable<Character> c){System.out.println("Comparable<Character>");}
	
}
当注释掉public void overLoad(char c){System.out.println("char");}方法时,编译器并没有报错,而是选择了public void overLoad(int c){System.out.println("int");},同样当注释掉public void overLoad(int c){System.out.println("int");}时,会继续将类型进行扩大,以此类推,调用方法的优先级顺序为 char->int->long->float->double->Character->接口(Serilizable)->父类(Object)->Object....objs

有一点需要注意的是,因为Character extends Object implements java.io.Serializable, Comparable<Character>,如果注释掉Serilizable类型参数前面的方法,则因为Serializable 和Compareable<Character>都是接口,所以有同样的优先级,这回让编译器不能确认具体的方法版本,会拒绝编译



动态分派(Override):

动态分派与java的另外一个重要特性,重写(Override)有这非常紧密的关系,下面通过一个简单的例子来说明虚拟机到底是如何实现Override的

package com.eric.jvm.executor;

/**
 * 关于Override的例子
 * 
 * @author Eric
 * 
 */
public class MethodOverrideDemonstrate {
	
	public static void main(String[] args) {
		MethodOverrideDemonstrate demonstrate = new MethodOverrideDemonstrate();
		Parent parent = demonstrate.new Parent();
		Parent father = demonstrate.new Father();
		Parent mother = demonstrate.new Mother();
		
		parent.printInfo();
		father.printInfo();
		mother.printInfo();
	}
	
	class Parent {
		public void printInfo() {
			System.out.println("Parent output....");
		}
	}
	
	class Father extends Parent {
		public void printInfo() {
			System.out.println("Father output....");
		}
	}
	
	class Mother extends Parent {
		public void printInfo() {
			System.out.println("Mother output....");
		}
	}
	
}
//output

Parent output....
Father output....
Mother output.... 

因为静态分派是通过静态类型类确定方法版本的,所以可以推断出动态分派是根据动态类型类确定方法版本的,更具体的说是因为在例子中printInfo()方法为虚方法,执行虚方法的虚拟机指令为invokevirtual.而该指令的执行过程如下,由此可见,动态类型对于Override的重要性

单分派,多分派

方法的接受者以及方法的方法的参数统称为宗量.单分派即用一个宗量来确定执行的方法,多分派就是用多个方法来确定被执行的方法

package com.eric.jvm.executor;

public class SingleMultiDispatch {
	
	/**
	 * 演示单分派,多分派
	 * 
	 * @param args
	 */
	
	public static void main(String[] args) {
		Parent parent=new Parent();
		Parent son=new Son();
		parent.buy(new IPhone());
		son.buy(new Sumsung());
	}
	
	
	
	static class Parent{
		public void buy(IPhone ipPhone){System.out.println("parent buy iphone");};
		public void buy(Sumsung sumsung){System.out.println("parent buy sumsung");};
	}
	
	static class Son extends Parent{
		public void buy(IPhone ipPhone){System.out.println("son buy iphone");};
		public void buy(Sumsung sumsung){System.out.println("son buy sumsung");};
	}
	
	static class Sumsung {}
	static class IPhone {}
	
}

编译阶段的方法选择过程(静态分派)为,首先根据静态类型判断是Parent还是Son类确定静态类型,然后还要根据参数来决定动态类型,所以静态分派为多分派

运行阶段虚拟机选择的过程(动态分派)为,首先在编译阶段确定了方法签名位buy(Sumsung),所以这个时候参数已经确定了,唯一不能确定的就是方法的实际接受者,因此只有一个宗量,即动态分派为单分派



阅读更多
个人分类: JVM
所属专栏: 几篇文章理解JVM
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭