精华内容
下载资源
问答
  • 方法调用并不等同于方法执行,方法调用阶段唯一的任务就是确定被调用方法的版本(即调用哪一个方法),暂时还不涉及方法内部的具体运行过程。在程序运行时,进行方法调用是最普遍、最频繁的操作,Class文件的编译...

    方法调用并不等同于方法执行,方法调用阶段唯一的任务就是确定被调用方法的版本(即调用哪一个方法),暂时还不涉及方法内部的具体运行过程。在程序运行时,进行方法调用是最普遍、最频繁的操作,Class文件的编译过程中不包含传统编译中的连接步骤,一切方法调用在Class文件里面存储的都只是符号引用,而不是方法在实际运行时内存布局中的入口地址(相当于之前说的直接引用)。这个特性给Java带来了更强大的动态扩展能力,但也使得Java方法调用过程变得相对复杂起来,需要在类加载期间,甚至到运行期间才能确定目标方法的直接引用。

    解析调用一定是个静态的过程,在编译期间就完全确定,在类装载的解析阶段就会把涉及的符号引用全部转变为可确定的直接引用,不会延迟到运行期再去完成。而分派(Dispatch)调用则可能是静态的也可能是动态的,根据分派依据的宗量数可分为单分派和多分派。这两类分派方式的两两组合就构成了静态单分派、静态多分派、动态单分派、动态多分派4种分派组合情况。

    解析

    所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用,在类加载的解析阶段,会将其中的一部分符号引用转化为直接引用,这种解析能成立的前提是:方法在程序真正运行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的。换句话说,调用目标在程序代码写好、编译器进行编译时就必须确定下来。这类方法的调用称为解析(Resolution)。在Java语言中符合“编译期可知,运行期不可变”这个要求的方法,主要包括静态方法和私有方法两大类,前者与类型直接关联,后者在外部不可被访问,这两种方法各自的特点决定了它们都不可能通过继承或别的方式重写其他版本,因此它们都适合在类加载阶段进行解析。

    与之相对应的是,在Java虚拟机里面提供了5条方法调用字节码指令,分别如下。

    invokestatic:调用静态方法。

    invokespecial:调用实例构造器<init>方法、私有方法和父类方法。

    invokevirtual:调用所有的虚方法。

    invokeinterface:调用接口方法,会在运行时再确定一个实现此接口的对象。

    invokedynamic:先在运行时动态解析出调用点限定符所引用的方法,然后再执行该方法,在此之前的4条调用指令,分派逻辑是固化在Java虚拟机内部的,而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

    只要能被invokestatic和invokespecial指令调用的方法,都可以在解析阶段中确定唯一的调用版本,符合这个条件的有静态方法、私有方法、实例构造器、父类方法4类,它们在类加载的时候就会把符号引用解析为该方法的直接引用。这些方法可以称为非虚方法,与之相反,其他方法称为虚方法(除去final方法)。

    Java中的非虚方法除了使用invokestatic、invokespecial调用的方法之外还有一种,就是被final修饰的方法。虽然final方法是使用invokevirtual指令来调用的,但是由于它无法被覆盖,没有其他版本,所以也无须对方法接收者进行多态选择,又或者说多态选择的结果肯定是唯一的。在Java语言规范中明确说明了final方法是一种非虚方法。

    分派

    Java是一门面向对象的程序语言,因为Java具备面向对象的3个基本特征:继承、封装和多态。分派调用过程将会揭示多态性特征的一些最基本的体现,如“重载”和“重写”在Java虚拟机之中是如何实现的,这里的实现当然不是语法上该如何写,我们关心的依然是虚拟机如何确定正确的目标方法

    静态分派

    public class StaticDispatch{
        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();
            StaticDispatch sr=new StaticDispatch();
            sr.sayHello(man);
            sr.sayHello(woman);
        }
    }
    
    hello,guy!
    hello,guy!

    main()里面的两次sayHello()方法调用,在方法接收者已经确定是对象“sr”的前提下,使用哪个重载版本,就完全取决于传入参数的数量和数据类型。代码中刻意地定义了两个静态类型相同但实际类型不同的变量,但虚拟机(准确地说是编译器)在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译期可知的,因此,在编译阶段,Javac编译器会根据参数的静态类型决定使用哪个重载版本,所以选择了sayHello(Human)作为调用目标,并把这个方法的符号引用写到main()方法里的两条invokevirtual指令的参数中。所有依赖静态类型来定位方法执行版本的分派动作称为静态分派。静态分派的典型应用是方法重载。静态分派发生在编译阶段,因此确定静态分派的动作实际上不是由虚拟机来执行的。另外,编译器虽然能确定出方法的重载版本,但在很多情况下这个重载版本并不是“唯一的”,往往只能确定一个“更加合适的”版本。这种模糊的结论在由0和1构成的计算机世界中算是比较“稀罕”的事情,产生这种模糊结论的主要原因是字面量不需要定义,所以字面量没有显式的静态类型,它的静态类型只能通过语言上的规则去理解和推断。何为“更加合适的”版本。

    public class Overload{
        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)方法,那输出会变为:

    hello int

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

    hello long

    这时发生了两次自动类型转换,'a'转型为整数97之后,进一步转型为长整数97L,匹配了参数类型为long的重载。笔者在代码中没有写其他的类型如float、double等的重载,不过实际上自动转型还能继续发生多次,按照char->int->long->float->double的顺序转型进行匹配。但不会匹配到byte和short类型的重载,因为char到byte或short的转型是不安全的。我们继续注释掉sayHello(long arg)方法,那输出会变为:

    hello Character

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

    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)方法,输出会变为:

    hello Object

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

    hello char……

    7个重载方法已经被注释得只剩一个了,可见变长参数的重载优先级是最低的,这时候字符'a'被当做了一个数组元素。使用的是char类型的变长参数,在验证时还可以选择int类型、Character类型、Object类型等的变长参数重载来把上面的过程重新演示一遍。但要注意的是,有一些在单个参数中能成立的自动转型,如char转型为int,在变长参数中是不成立的。

    另外还有一点可能比较容易混淆:解析与分派这两者之间的关系并不是二选一的排他关系,它们是在不同层次上去筛选、确定目标方法的过程。例如,前面说过,静态方法会在类加载期就进行解析,而静态方法显然也是可以拥有重载版本的,选择重载版本的过程也是通过静态分派完成的。

    动态分派

     

    public class DynamicDispatch{
        static abstract class Human{
            protected abstract void sayHello();
        }
        static class Man extends Human{
            @Override
            protected void sayHello(){
                System.out.println("man say hello");
            }
        }
        static class Woman extends Human{
            @Override
            protected void sayHello(){
                System.out.println("woman say hello");
            }
        }
        public static void main(String[]args){
            Human man=new Man();
            Human woman=new Woman();
            man.sayHello();
            woman.sayHello();
            man=new Woman();
            man.sayHello();
        }
    }
    运行结果:
    man say hello
    woman say hello
    woman say hello

    虚拟机是如何知道要调用哪个方法的?显然这里不可能再根据静态类型来决定,因为静态类型同样都是Human的两个变量man和woman在调用sayHello()方法时执行了不同的行为,并且变量man在两次调用中执行了不同的方法。导致这个现象的原因很明显,是这两个变量的实际类型不同,Java虚拟机是如何根据实际类型来分派方法执行版本的呢?

    main()方法的字节码
    public static void main(java.lang.String[]);
    Code:
    Stack=2,Locals=3,Args_size=1
    0:new#16;//class org/fenixsoft/polymorphic/Dynamic-Dispatch $Man
    3:dup
    4:invokespecial#18;//Method org/fenixsoft/polymorphic/Dynamic-Dispatch $Man."<init>":()V
    7:astore_1
    8:new#19;//class org/fenixsoft/polymorphic/Dynamic-Dispatch $Woman
    11:dup
    12:invokespecial#21;//Method org/fenixsoft/polymorphic/DynamicDispatch $Woman."<init>":()V
    15:astore_2
    16:aload_1
    17:invokevirtual#22;//Method org/fenixsoft/polymorphic/Dynamic-Dispatch $Human.sayHello:()V
    20:aload_2
    21:invokevirtual#22;//Method org/fenixsoft/polymorphic/Dynamic-Dispatch $Human.sayHello:()V
    24:new#19;//class org/fenixsoft/polymorphic/Dynamic-Dispatch $Woman
    27:dup
    28:invokespecial#21;//Method org/fenixsoft/polymorphic/DynamicDispatch $Woman."<init>":()V
    31:astore_1
    32:aload_1
    33:invokevirtual#22;//Method org/fenixsoft/polymorphic/DynamicDispatch $Human.sayHello:()V
    36:return
    0~15行的字节码是准备动作,作用是建立man和woman的内存空间、调用Man和Woman类型的实例构造器,将这两个实例的引用存放在第1、2个局部变量表Slot之中,
    这个动作也就对应了代码中的这两句: Human man
    = newMan(); Human woman = newWoman();

    接下来的16~21句是关键部分,16、20两句分别把刚刚创建的两个对象的引用压到栈顶,这两个对象是将要执行的sayHello()方法的所有者,称为接收者(Receiver);17和21句是方法调用指令,这两条调用指令单从字节码角度来看,无论是指令(都是invokevirtual)还是参数(都是常量池中第22项的常量,注释显示了这个常量是Human.sayHello()的符号引用)完全一样的,但是这两句指令最终执行的目标方法并不相同。

    原因就需要从invokevirtual指令的多态查找过程开始说起,invokevirtual指令的运行时解析过程大致分为以下几个步骤:

    1)找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C。

    2)如果在类型C中找到与常量中的描述符和简单名称都相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过程结束;如果不通过,则返回java.lang.IllegalAccessError异常。

    3)否则,按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。

    4)如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError异常。

    由于invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型,所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上,这个过程就是Java语言中方法重写的本质。我们把这种在运行期根据实际类型确定方法执行版本的分派过程称为动态分派

    单分派与多分派

    方法的接收者方法的参数统称为方法的宗量,这个定义最早应该来源于《Java与模式》一书。根据分派基于多少种宗量,可以将分派划分为单分派和多分派两种。单分派是根据一个宗量对目标方法进行选择,多分派则是根据多于一个宗量对目标方法进行选择。

    列举了一个Father和Son一起来做出“一个艰难的决定”的例子。

    public class Dispatch{
        static class QQ{}
        static class_360{}
        public static class Father{
            public void hardChoice(QQ arg){
                System.out.println("father choose qq");
            }
            public void hardChoice(_360 arg){
                System.out.println("father choose 360");
            }
        }
        public static class Son extends Father{
            public void hardChoice(QQ arg){
                System.out.println("son choose qq");
            }
            public void hardChoice(_360 arg){
                System.out.println("son choose 360");
            }
        }
        public static void main(String[]args){
            Father father=new Father();
            Father son=new Son();
            father.hardChoice(new_360());
            son.hardChoice(new QQ());
        }
    }
    运行结果:
    father choose 360
    son choose qq

    在main函数中调用了两次hardChoice()方法,这两次hardChoice()方法的选择结果在程序输出中已经显示得很清楚了。

    我们来看看编译阶段编译器的选择过程,也就是静态分派的过程。这时选择目标方法的依据有两点:一是静态类型是Father还是Son,二是方法参数是QQ还是360。这次选择结果的最终产物是产生了两条invokevirtual指令,两条指令的参数分别为常量池中指向Father.hardChoice(360)及Father.hardChoice(QQ)方法的符号引用因为是根据两个宗量进行选择,所以Java语言的静态分派属于多分派类型。

    再看看运行阶段虚拟机的选择,也就是动态分派的过程。在执行“son.hardChoice(new QQ())”这句代码时,更准确地说,是在执行这句代码所对应的invokevirtual指令时,由于编译期已经决定目标方法的签名必须为hardChoice(QQ),虚拟机此时不会关心传递过来的参数“QQ”到底是“腾讯QQ”还是“奇瑞QQ”,因为这时参数的静态类型、实际类型都对方法的选择不会构成任何影响,唯一可以影响虚拟机选择的因素只有此方法的接受者的实际类型是Father还是Son。因为只有一个宗量作为选择依据,所以Java语言的动态分派属于单分派类型。

     

    虚拟机动态分派的实现

    由于动态分派是非常频繁的动作,而且动态分派的方法版本选择过程需要运行时在类的方法元数据中搜索合适的目标方法,因此在虚拟机的实际实现中基于性能的考虑,大部分实现都不会真正地进行如此频繁的搜索。面对这种情况,最常用的“稳定优化”手段就是为类在方法区中建立一个虚方法表(Vritual Method Table,也称为vtable,与此对应的,在invokeinterface执行时也会用到接口方法表——Inteface Method Table,简称itable),使用虚方法表索引来代替元数据查找以提高性能。

    虚方法表中存放着各个方法的实际入口地址如果某个方法在子类中没有被重写,那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的,都指向父类的实现入口。如果子类中重写了这个方法,子类方法表中的地址将会替换为指向子类实现版本的入口地址。Son重写了来自Father的全部方法,因此Son的方法表没有指向Father类型数据的箭头。但是Son和Father都没有重写来自Object的方法,所以它们的方法表中所有从Object继承来的方法都指向了Object的数据类型。

    为了程序实现上的方便,具有相同签名的方法,在父类、子类的虚方法表中都应当具有一样的索引序号,这样当类型变换时,仅需要变更查找的方法表,就可以从不同的虚方法表中按索引转换出所需的入口地址。方法表一般在类加载的连接阶段进行初始化,准备了类的变量初始值后,虚拟机会把该类的方法表也初始化完毕。

    ps:方法表是分派调用的“稳定优化”手段,虚拟机除了使用方法表之外,在条件允许的情况下,还会使用内联缓存(Inline Cache)和基于“类型继承关系分析”(Class Hierarchy Analysis,CHA)技术的守护内联(Guarded Inlining)两种非稳定的“激进优化”手段来获得更高的性能,关于这两种优化技术的原理和运作过程,可以参考JIT晚期运行期。

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • java多态实现JVM调用过程

    千次阅读 2018-05-22 10:56:06
    多态同一个类不同表现形态,不同形态是通过其不同子类体现 java通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。面向对象三个特征与含义下面看例子:public class A{ public String name = &...

    多态

    同一个类的不同表现形态,不同的形态是通过其不同的子类体现 java通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。

    面向对象的三个特征与含义

    下面看例子:

    public class A{
                public String name = "父类name";
                public void move(){
                    System.out.println("父类move");
                }
    }
    
    public class B extends A{
        public String name = "子类name";
        @Override
        public void move() {
            // TODO Auto-generated method stub
            System.out.println("子类move");
        }  
    }
    
    public class Test {
        public static void main(String[] args) {
            A a = new B();
            a.move();
            }
          }
    
    

    类B是类A的子类, A a = new B() 编译时变量和运行时变量不一样,所以多态发生了。

    ① A a 作为一个引用类型数据,存储在JVM栈的本地变量表中。 ② new B()作为实例对象数据存储在堆中    B的对象实例数据(接口、方法、field、对象类型等)的地址也存储在堆中    B的对象的类型数据(对象实例数据的地址所执行的数据)存储在方法区中,方法区中 对象类型数据 中有一个指向该类方法的方法表

    ③Java虚拟机规范中并未对引用类型访问具体对象的方式做规定,目前主流的实现方式主要有两种:

     1. 通过句柄访问

     这里写图片描述

      在这种方式中,JVM堆中会专门有一块区域用来作为句柄池,存储相关句柄所执行的实例数据地址(包括在堆中地址和在方法区中的地址)。这种实现方法由于用句柄表示地址,因此十分稳定

    2.通过直接指针访问

     这里写图片描述 

      通过直接指针访问的方式中,reference中存储的就是对象在堆中的实际地址,在堆中存储的对象信息中包含了在方法区中的相应类型数据。这种方法最大的优势是速度快,在HotSpot虚拟机中用的就是这种方式。对象头包括类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。

    ④实现过程

      首先虚拟机通过reference类型(A的引用)查询java栈中的 本地变量表,得到堆中的 对象类型数据的地址,然后通过到对象的指针找到方法区中的 对象类型数据(B的对象类型数据) ,然后查询方法表定位到实际类(B类)的方法运行。


    参考:

    https://github.com/helen-x/AndroidInterview/blob/master/java/%5Bjava%5D%20%E5%A4%9A%E6%80%81%E5%AE%9E%E7%8E%B0%E7%9A%84JVM%E8%B0%83%E7%94%A8%E8%BF%87%E7%A8%8B.md

    展开全文
  • java通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。 面向对象三个特征与含义 下面看例子: public class A{ public String name = "父类name"; public void move(){

    多态

    同一个类的不同表现形态,不同的形态是通过其不同的子类体现 
    java通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。

    面向对象的三个特征与含义

    下面看例子:

    <code class="hljs cs has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal; background: transparent;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">class</span> A{
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> String name = <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"父类name"</span>;
                <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> <span class="hljs-title" style="box-sizing: border-box;">move</span>(){
                    System.<span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">out</span>.println(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"父类move"</span>);
                }
    }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li></ul><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li></ul>
    <code class="hljs java has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal; background: transparent;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-class" style="box-sizing: border-box;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">class</span> <span class="hljs-title" style="box-sizing: border-box; color: rgb(102, 0, 102);">B</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">extends</span> <span class="hljs-title" style="box-sizing: border-box; color: rgb(102, 0, 102);">A</span>{</span>
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> String name = <span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"子类name"</span>;
        <span class="hljs-annotation" style="color: rgb(155, 133, 157); box-sizing: border-box;">@Override</span>
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> <span class="hljs-title" style="box-sizing: border-box;">move</span>() {
            <span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box;">// TODO Auto-generated method stub</span>
            System.out.println(<span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box;">"子类move"</span>);
        }  
    }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li></ul><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li></ul>
    <code class="hljs cs has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-radius: 0px; word-wrap: normal; background: transparent;"><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">class</span> Test {
        <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">public</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">static</span> <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">void</span> <span class="hljs-title" style="box-sizing: border-box;">main</span>(String[] args) {
            A a = <span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box;">new</span> B();
            a.move();
            }
          }
    </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li></ul><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li></ul>

    类B是类A的子类, A a = new B() 编译时变量和运行时变量不一样,所以多态发生了。

    ① A a 作为一个引用类型数据,存储在JVM栈的本地变量表中。 
    ② new B()作为实例对象数据存储在堆中 
       B的对象实例数据(接口、方法、field、对象类型等)的地址也存储在堆中 
       B的对象的类型数据(对象实例数据的地址所执行的数据)存储在方法区中,方法区中 对象类型数据 中有一个指向该类方法的方法表

    ③Java虚拟机规范中并未对引用类型访问具体对象的方式做规定,目前主流的实现方式主要有两种:

     1. 通过句柄访问 
    这里写图片描述

      在这种方式中,JVM堆中会专门有一块区域用来作为句柄池,存储相关句柄所执行的实例数据地址(包括在堆中地址和在方法区中的地址)。这种实现方法由于用句柄表示地址,因此十分稳定

    2.通过直接指针访问 
    这里写图片描述 

      通过直接指针访问的方式中,reference中存储的就是对象在堆中的实际地址,在堆中存储的对象信息中包含了在方法区中的相应类型数据。这种方法最大的优势是速度快,在HotSpot虚拟机中用的就是这种方式。

    ④实现过程

      首先虚拟机通过reference类型(A的引用)查询java栈中的 本地变量表,得到堆中的 对象类型数据的地址,从而找到方法区中的 对象类型数据(B的对象类型数据) ,然后查询方法表定位到实际类(B类)的方法运行。

    转载:http://blog.csdn.net/amazing7/article/details/51226131

    展开全文
  • 调用的draw()方法是被子类对象覆盖后draw()方法而不是基类draw()方法,这时需要特别注意一个地方。这里由于第一步缘故,radius值为0; 其次,按照声明顺序调用成员初始化方法。 最后就是调用导出类...

    首先看一下代码:

    class Glyph{
        void draw(){ System.out.println("Glyph.draw()");}
        Glyph(){
            System.out.println("Glyph() before draw()");
            draw();
            System.out.println("Glyph() after  draw()");
        }
    }
    
    class RoundGlyph extends Glyph{
        private int radius = 1;
        RoundGlyph(int i){
            radius = i;
            System.out.println("RoundGlyph.RoundGlyph(),  radius = " + radius);
        }
        void draw(){
             System.out.println("RoundGlyph.draw(),  radius = " + radius);
        }
    }
    
    public class PolyConstructors{
        public static void main(String[] args){
            new RoundGlyph(5);
        }
    }
    View Code

    好,我们跑一下,纳尼,为什么输出的是

    Glyph() before draw()
    RoundGlyph.draw(), radius = 0
    Glyph() after draw()
    RoundGlyph.RoundGlyph(), radius = 5

    下面我来说一下运行过程中的过程,我想你们就知道为什么会这样了。

    首先,在其他任何事物发生之前,将分配给对象的存储空间全都初始化为二进制的零。

    然后,开始调用构造器,先调用基类的构造器,在这个过程中,调用的draw()方法是被子类对象覆盖后的draw()方法而不是基类的draw()方法,这时需要特别注意的一个地方。这里由于第一步的缘故,radius的值为0;

    其次,按照声明的顺序调用成员的初始化方法。

    最后就是调用导出类的构造器了。





    转载于:https://www.cnblogs.com/xiaofanguoguo/p/3843409.html

    展开全文
  • 其次,可以看到我已经为FatherClass和SonClass它们都分别显示地创建了无参构造方法,但是我运行结果中,并没有调用FatherClass无参构造方法也没有调用子类SonClass无参构造方法啊?是怎么回事呢? 这是我...
  • 书中写道,假设要调用x.f(args),隐式参数x声明为类C一个对象,调用过程的详细描述: 编译器查看对象声明类型和方法名,编译器一一列举所有C类中名为f的方法以及其超类中访问属性为public且名为f的方法 编译器...
  • 此时,调用被覆盖后draw()方法(注意这一步是在调用子类RoundGlyph构造器之前调用的)。由于步骤1,所有此时radius值是0。 3.按照声明顺序调用成员初始化方法。 4.调用子类构造器主体。 package ...
  • 在Java中,多态是指不同类对象在调用同一个方法时所呈现出多种不同行为。通常来说,在一个类中定义属性和方法被其他类继承或重写后,当把子类对象直接赋值给父类引用变量时,相同引用类型变量调用同一个方法...
  • Java中构造器内部的多态方法的行为

    千次阅读 2016-09-12 20:17:33
    这篇文章主要讨论的是,若在一个构造器中调用正在构造的...1. 复杂层次结构中构造器的调用顺序 基类的构造器总是在导出类的构造过程中被调用,而且按照继承层次逐渐向上链接,以使每个基类的构造器都能得到调用。这
  • 总体而言,当某个方法被调用时,JVM 首先要查找相应的常量池,得到方法的符号引用,并查找调用类的方法表以确定该方法的直接引用,最后才真正调用该方法。以下分别对该过程中涉及到的相关部分做详细介绍。JVM 的结构...
  • 在日常撸代码的过程当中,总结了多态调用子类特有方法的2种方式,现整理如下,如有错误,欢迎批评指正,不多说,先上代码! public class Animal{ //父类 public void eat(){ System.out.println(...
  • 如果在超类构建器中调用了子类覆盖过的方法,则编译器默认会调用在超类构建的过程调用已经被子类覆盖过的方法,而不是超类中原始方法。这种错误很难从逻辑上进行排查,所以一定要格外小心!以下是例子: ...
  • 004 Java面向对象知识点Java是一种面向对象的编程语言抽象封装继承多态Java的基本概念Java的命名方式生成JavaDoc文档类方法的调用包的作用和命名规范属性和方法 Java是一种面向对象的编程语言 面向对象程序的 OOP...
  • 方法的调用 在JVM中,将符号引用(方法体或者构造方法体内 图1)转换为调用方法的直接引用(图2)与方法的绑定机制相关。 图1 图2 静态链接:(也就是说,直接引用可以在编译期间确定下来) 当一...
  • 静态绑定: 在编译期就已经知道调用哪个对象什么方法。 动态绑定: 只有到运行期才知道调用哪个对象什么方法。 假定一个对象x(其为X类),调用m方法: x.m(); JVM实际动作是怎么样呢? 1. 根据对象x...
  • 方法的重载、类的覆盖正体现了多态。 1、多态的机制 1.1 本质上多态分两种 1、编译时多态(又称静态多态) 2、运行时多态(又称动态多态) 重载(overload 发生在一个类中,方法名必须相同,不同参数...
  • import static lu.utils.Print.*; /*  * 在任何构造器内部,整个对象可能只是部分形成——我们只知道... * 类导出,那么导出部分在当前构造器正在被调用的时刻仍旧是没有被初始化。然而,  * 一个动态
  • 多态的使用过程中,不论调用的属性是否为静态,都执行是父类属性。 如果方法为非静态方法调用的执行是子类中重写后的方法 如果方法为静态方法调用的执行为父类中的方法 ...
  • 置换法则: 超类对象任何地方都可以用子类对象置换。 一个超类变量既可以引用一个超类对象,也可以引用超类任何一个子类对象。如: ...Manager boss = new ...这个过程也被称为向上转型,在向上转型以...
  • Java面向对象的最重要的一个特点就是多态, 而多态当中涉及到了一个重要的机制是动态...对象是Java中最重要的概念, 弄清楚对象方法的调用执行过程会对Java对象有更深层了理解。下面是<Core Java>中对调用过程
  • 多态

    2020-07-23 12:13:44
    多态任务号3 输出医生给宠物病的过程实现多态1.认识多态2.向上转型3.向下转型4. instanceof 运算符多态的应用1.使用父类作为方法的形参2.使用父类作为方法的返回值 任务号3 输出医生给宠物病的过程 关键步骤如下。 ...
  • 多态的缺陷

    2017-08-06 17:49:42
    多态的调用过程中涉及到了方法的绑定(所谓方法绑定就是将一个方法调用和方法主体关联起来的过程)。若在程序执行之前,由编译程序进行绑定的过程称之为前期绑定。(C语言就是前期绑定)。而java中实现多态的机制就...
  • 抽象方法的演变过程:为了减少代码量,同时为了实现在父类中的某个方法有多种表示形态,因此在继承的前提下使用多态(继承是为了多态多态的前提时继承),为了实现多态,子类往往会重写父类的方法,使用向上转型...
  • 方法的覆盖:子类对父类成员方法的覆盖:方法名、参数、返回值...构造方法的调用过程,当调用构造方法过程遇到大括号,流程跳转至调用该方法处,当在主类中调用子类的空参数构造方法时,流程会自动跳转到父类中的空...
  • 今天记录一下学习过程中golang与java多态的对比。 一、Golang 在golang中,多态主要是通过接口实现。 可以按照同一接口来调用不同实现,这时接口变量就呈现不同形态 并且相对于java,少了extends和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,332
精华内容 532
关键字:

多态方法的调用过程