java中的静态分派和动态分派

最新推荐文章于 2022-08-28 21:42:49 发布
最新推荐文章于 2022-08-28 21:42:49 发布
阅读量528 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ly853602/article/details/92979532
版权

1.理解前提

在理解静态分派和动态分派之前我们需要先理解静态类型和动态类型。

静态类型，是在编译期间可知的，什么意思呢，就是在使用javac命令编译java文件时确定的指令集。

动态类型，则是编译期间不可知，只有在运行期间才能确定的。

2.静态分派

为了更好的说明静态分派，参考如下重载方法的代码

public class Person {

    public void sayHello() {
        System.out.println("hello person");
    }

    public void sayHello(String hello) {
        System.out.println(hello);
    }

    public void sayGoodBye() {
        System.out.println("goodbye person");
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.sayHello();
        person.sayHello("hello again Person");
    }
}

然后使用javac 命令反编译Person.class文件得到如下

javac -c -v Person.class
Classfile /E:/Pro_bak/QGZWXX/QGZWXX/WebContent/js/sys/Person.class
  Last modified 2019-6-20; size 909 bytes
  MD5 checksum 71d7cd35bec0c71e958b464fb68b1722
  Compiled from "Person.java"
public class array.Person
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #11.#31        // java/lang/Object."<init>":()V
   #2 = Fieldref           #32.#33        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #34            // hello person
   #4 = Methodref          #35.#36        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = String             #37            // goodbye person
   #6 = Class              #38            // array/Person
   #7 = Methodref          #6.#31         // array/Person."<init>":()V
   #8 = Methodref          #6.#39         // array/Person.sayHello:()V
   #9 = String             #40            // hello again Person
  #10 = Methodref          #6.#41         // array/Person.sayHello:(Ljava/lang/String;)V
  #11 = Class              #42            // java/lang/Object
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               Larray/Person;
  #19 = Utf8               sayHello
  #20 = Utf8               (Ljava/lang/String;)V
  #21 = Utf8               hello
  #22 = Utf8               Ljava/lang/String;
  #23 = Utf8               sayGoodBye
  #24 = Utf8               main
  #25 = Utf8               ([Ljava/lang/String;)V
  #26 = Utf8               args
  #27 = Utf8               [Ljava/lang/String;
  #28 = Utf8               person
  #29 = Utf8               SourceFile
  #30 = Utf8               Person.java
  #31 = NameAndType        #12:#13        // "<init>":()V
  #32 = Class              #43            // java/lang/System
  #33 = NameAndType        #44:#45        // out:Ljava/io/PrintStream;
  #34 = Utf8               hello person
  #35 = Class              #46            // java/io/PrintStream
  #36 = NameAndType        #47:#20        // println:(Ljava/lang/String;)V
  #37 = Utf8               goodbye person
  #38 = Utf8               array/Person
  #39 = NameAndType        #19:#13        // sayHello:()V
  #40 = Utf8               hello again Person
  #41 = NameAndType        #19:#20        // sayHello:(Ljava/lang/String;)V
  #42 = Utf8               java/lang/Object
  #43 = Utf8               java/lang/System
  #44 = Utf8               out
  #45 = Utf8               Ljava/io/PrintStream;
  #46 = Utf8               java/io/PrintStream
  #47 = Utf8               println
{
  public array.Person();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Larray/Person;

  public void sayHello();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello person
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Larray/Person;

  public void sayHello(java.lang.String);
    descriptor: (Ljava/lang/String;)V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=2, args_size=2
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_1
         4: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         7: return
      LineNumberTable:
        line 10: 0
        line 11: 7
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       8     0  this   Larray/Person;
            0       8     1 hello   Ljava/lang/String;

  public void sayGoodBye();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String goodbye person
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 14: 0
        line 15: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Larray/Person;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #6                  // class array/Person
         3: dup
         4: invokespecial #7                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: invokevirtual #8                  // Method sayHello:()V
        12: aload_1
        13: ldc           #9                  // String hello again Person
        15: invokevirtual #10                 // Method sayHello:(Ljava/lang/String;)V
        18: return
      LineNumberTable:
        line 18: 0
        line 19: 8
        line 20: 12
        line 21: 18
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      19     0  args   [Ljava/lang/String;
            8      11     1 person   Larray/Person;
}
SourceFile: "Person.java"

我们重点关注反编译文件中的图示内容

 在java代码里面分别调用了sayHello()和sayHello(String hello)两个重载的方法。

通过图中红框我们可以看出，在编译文件中已经分别确定了调用的方法，没有混淆，而这个过程并没有经过虚拟机运行，所以这个确认重载方法调用的过程在编译期间就完成了，这个过程就是静态分派。而两个方法中的参数就可以成为是静态类型。总而言之，根据静态类型定位方法执行版本的分派动作成为静态分派。

3.动态分派

为了更好的说明，我们使用重写，代码如下，两个类，Person和Man

public class Person {

    public void sayHello() {
        System.out.println("hello person");
    }

    public void sayHello(String hello) {
        System.out.println(hello);
    }

    public void sayGoodBye() {
        System.out.println("goodbye person");
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.sayHello();
        person.sayHello("hello again Person");
    }
}


public class Man extends Person {
    @Override
    public void sayGoodBye() {
        System.out.println("goodbye man");
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.sayGoodBye();
        person = new Man();
        person.sayGoodBye();
    }
}

如代码所示重写了sayGoodBye()，这个时候我们反编译Man.class

javac -c -v Man.class

结果如下

Classfile /E:/Pro_bak/QGZWXX/QGZWXX/WebContent/js/sys/Man.class
  Last modified 2019-6-20; size 681 bytes
  MD5 checksum dc174ca15248b325b11b4e27edbdff77
  Compiled from "Man.java"
public class array.Man extends array.Person
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#25         // array/Person."<init>":()V
   #2 = Fieldref           #26.#27        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #28            // goodbye man
   #4 = Methodref          #29.#30        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #31            // array/Person
   #6 = Methodref          #5.#32         // array/Person.sayGoodBye:()V
   #7 = Class              #33            // array/Man
   #8 = Methodref          #7.#25         // array/Man."<init>":()V
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Utf8               LineNumberTable
  #13 = Utf8               LocalVariableTable
  #14 = Utf8               this
  #15 = Utf8               Larray/Man;
  #16 = Utf8               sayGoodBye
  #17 = Utf8               main
  #18 = Utf8               ([Ljava/lang/String;)V
  #19 = Utf8               args
  #20 = Utf8               [Ljava/lang/String;
  #21 = Utf8               person
  #22 = Utf8               Larray/Person;
  #23 = Utf8               SourceFile
  #24 = Utf8               Man.java
  #25 = NameAndType        #9:#10         // "<init>":()V
  #26 = Class              #34            // java/lang/System
  #27 = NameAndType        #35:#36        // out:Ljava/io/PrintStream;
  #28 = Utf8               goodbye man
  #29 = Class              #37            // java/io/PrintStream
  #30 = NameAndType        #38:#39        // println:(Ljava/lang/String;)V
  #31 = Utf8               array/Person
  #32 = NameAndType        #16:#10        // sayGoodBye:()V
  #33 = Utf8               array/Man
  #34 = Utf8               java/lang/System
  #35 = Utf8               out
  #36 = Utf8               Ljava/io/PrintStream;
  #37 = Utf8               java/io/PrintStream
  #38 = Utf8               println
  #39 = Utf8               (Ljava/lang/String;)V
{
  public array.Man();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method array/Person."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Larray/Man;

  public void sayGoodBye();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String goodbye man
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  this   Larray/Man;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #5                  // class array/Person
         3: dup
         4: invokespecial #1                  // Method array/Person."<init>":()V
         7: astore_1
         8: aload_1
         9: invokevirtual #6                  // Method array/Person.sayGoodBye:()V
        12: new           #7                  // class array/Man
        15: dup
        16: invokespecial #8                  // Method "<init>":()V
        19: astore_1
        20: aload_1
        21: invokevirtual #6                  // Method array/Person.sayGoodBye:()V
        24: return
      LineNumberTable:
        line 10: 0
        line 11: 8
        line 12: 12
        line 13: 20
        line 14: 24
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      25     0  args   [Ljava/lang/String;
            8      17     1 person   Larray/Person;
}
SourceFile: "Man.java"

重点关注图示部分

 图中红框标记显示，两个调用都是Person中的sayGoodBye()方法，但是我们都知道，第二个应该是调用Man中重写的sayGoodBye()，所以编译期间具体调用的对象是不能确定的，要到虚拟机中运行的时候才能确定，总而言之，在虚拟机运行期间确定分派的过程称为动态分派。

韩信的兵
关注
java静态分配和动态分配
05-01 1万+
1.方法调用 先来说说java方法的调用，方法的调用不等于方法执行，方法调用阶段唯一的任务是确定被调用方法的版本（即调用哪个方法，不是唯一的，确定一个“更加合适”的版本），不涉及方法内部的具体运行过程。 我们都是知道java文件都需要编译成class文件，而一切方法调用在class文件里存储的都是符号引用，而不是方法的实际运行时内存布局的入口地址（相当于直接引用）。在类加载的解析阶段，会将其中
对于Java是静态多分派、动态单分派语言的理解
Joker小兮的博客
03-04 503
在理解这个之前，首先我们需要知道：在JVM中，方法的调用过程 这里的方法调用并不指方法中的代码被执行，而是指确定被调用方法的版本 （即调用哪一个方法） 方法的调用分为两个阶段，分别是解析阶段和分派阶段 解析阶段 也就是我们在Java基础中了解的前期绑定，或者说静态绑定，指代的是在编译期间就能够确定执行的是哪个方法。 分类 final修饰的方法 static修饰的方法 private修饰的方法 构造方法 分派 也就是后期绑定，或者说动态绑定，指代的是在运行期间才能够确定执行的是哪个方法。 注意：分派本身就
Java静态分派和动态分派
_Hihi_的博客
05-09 492
动态类型和静态类型 动态类型和静态类型发生在继承和多态中，在创建对象时，同一个对象有动态类型和静态类型之分，等号左侧的是静态类型，等号右侧new出来的类型是动态类型。 动态分派和静态分派 静态分派是在编译期发生，动态分派在运行期发生。 静态分派和动态分派涉及到对象的动态类型和静态类型。 方法执行时，方法传参进去，不管参数的动态类型是什么，都按照静态类型执行。 静态分派确定参数静态类型，动态分派决定执行者的类型。 class Father { void eat(Father fat
java静态分派_Java中的静态分派和动态分派
weixin_34668147的博客
02-19 205
本文以Java多态的一些基本特征来谈一下分派调用。在开始，依旧用常用方式，例子来引入，看一看下面例子的输出：/**** @author Sel** 2014.4.3*/public class StaticDispatch {public void sayHello(Human guy) {System.out.println("hello, guy!");}public void sayHell...
Java静态分派与动态分派
北京Java青年
06-13 1726
方法调用并不等于方法执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即调用哪一个方法），暂时还不涉及方法内部的具体运行过程。 在程序运行时，进行方法调用是最普遍、最频繁的操作，但是Class文件的编译过程不包括传统编译中的连接步骤，一切方法调用在Class文件里面存储的都只是符号引用，而不是方法在实际运行时内存布局中的入口地址（相对于之前说的直接引用）。这个特性给Java带来了更强大的动态...
关于java的静态分派和动态分派
lxhseph的博客
05-05 442
先下结论：静态分派是根据方法参数的静态类型（外观类型）在编译期决定方法的特征签名；动态分派是 根据方法接受者的实际类型在运行时决定具体调用哪个方法。 public static Father{} public static Son extends Father{} Father a=new Son(); Employee b=new Manager(); a.methodTest(b);//这里会产生一个invokevirtual字节码指令，参数为常量池中指向的A::methodTest(Empl.
Java的动态分派和静态分派的实现
08-24
Java 中的动态分派和静态分派是通过 invokestatic、invokespecial、invokevirtual、invokeinterface、invokedynamic 等字节码指令来实现的。这些指令都是在方法调用过程中使用的。 Java 的动态分派和静态分派是 ...
【深入Java虚拟机】之五：多态性实现机制——静态分派与动态分派
热门推荐
兰亭风雨的专栏
01-10 4万+
Class文件的编译过程中不包含传统编译中的连接步骤，一切方法调用在Class文件里面存储的都只是符号引用，而不是方法在实际运行时内存布局中的入口地址。这个特性给Java带来了更强大的动态扩展能力，使得可以在类运行期间才能确定某些目标方法的直接引用，称为动态连接，也有一部分方法的符号引用在类加载阶段或第一次使用时转化为直接引用，这种转化称为静态解析。这在前面的“Java内存区域与内存溢出”一文中有提到。 静态解析成立的前提是：方法在程序真正执行前就有一个可确定的调用版本，并且这个方法的调用版本在运
Java的动态绑定与双分派_动力节点Java学院整理
08-29
Java的动态绑定与双分派是面向对象编程中两个重要的概念，它们关乎程序在运行时如何选择正确的方法执行。动态绑定，又称晚期绑定或虚函数调用，是Java等面向对象语言的一种特性，它允许在运行时根据对象的实际类型...
【深入Java虚拟机（5）】多态性实现机制-静态分派与动
最新发布
11-22
了解静态分派和动态分派对于理解Java的多态行为至关重要，它们是优化代码、避免类型检查开销以及设计高效面向对象系统的基础。在实际编程中，合理利用这两种机制可以提高代码的可读性和可维护性，同时也能充分利用...
Java方法调用中的内涵：静态分派和动态分派
Aaron_涛
07-19 905
public class Solution { public void fun(Object i){ System.out.println("obbject"); } public void fun(Integer i){ System.out.println("Integer"); } public void fun(Float i){ System.out.p...
Swift 静态派发和动态派发
rstbfveradsvc
04-24 355
&#13; 前言 方法是 Swift 中的一个重要概念，方法允许你把需要复用的代码封装进方法中，这样当你调用方法时，实际上你的想法是执行方法中的那些代码，方法的出现极大的提高了方法的复用性。 Swift 工程的环境是非常复杂的，如何凭借方法的名字正确的找到方法中的代码实际上并不是听起来那样简单，在寻找代码的道路上又静态派发和动态派发两种不同的方式。 1、动态派发 OC ...
Java的静态分派和动态分派
qq_30698633的博客
08-08 324
静态分派：Java的静态分派只涉及到方法的重载，也就是我们实际调用的是哪个重载方法实际上是在编译期间确定的。 下面来举例说明一下： // 水果接口 interface Fruit{} // 苹果实现类 class Apple implements Fruit{ } // 橘子实现类 class Orange implements Fruit{ } // 重载方法 class
静态分派与动态分派
weixin_34198762的博客
03-22 118
为什么80%的码农都做不了架构师？>>> ...
Java多态的本质—动态分派
m0_68850571的博客
08-28 1119
Java语言的一大特性是多态性，所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。举个简单的例子，比如。...
Java中的静态分派和动态分派原理
攻城狮Chova的博客
03-03 451
Java中的静态分派和动态分派方法调用方法解析Java方法分类静态分派 方法调用 在程序运行时,进行方法调用是最普遍,最频繁的操作 方法调用不等于方法执行: 方法调用阶段唯一的任务就是确定被调用的方法版本,即调用哪一个方法 不涉及方法内部的具体运行过程 Class文件的编译过程不包括传统编译中的连接步骤 Class文件中的一切方法调用在Class文件里面存储的都是符号引用,而不是方法在在实...
Java虚拟机：静态分派和动态分派
qq_44688635的博客
02-28 235
参考资料《深入理解java虚拟机(第3版)》 目录静态分派和重载重载方法匹配优先级动态分派与重写字段永远不会参与多态静态分派是多分派，动态分派是单分派 静态分派和重载 public class StaticDispatch { static abstract class Human { } static class Man extends Human { } static class Woman extends Human{ } publi
JVM 方法调用之动态分派
weixin_30835649的博客
04-30 93
1. 动态分派 一个体现是重写(override)。下面的代码，运行结果很明显。 1 public class App { 2 3 public static void main(String[] args) { 4 Super object = new Sub(); 5 object.f(); 6 } 7...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值