Java中为什么静态方法不能被重写？为什么静态方法不能隐藏实例方法？

2022-10-26 18:08:27

问题描述

  Java中为什么静态方法不能被重写？为什么静态方法不能隐藏实例方法？诸如此类。

前期准备

  首先理解重写的意思，重写就是子类中对父类的实例方法进行重新定义功能，且返回类型、方法名以及参数列表保持一致，且对重写方法的调用主要看实际类型。实际类型如果实现了该方法则直接调用该方法，如果没有实现，则在继承关系中从低到高搜索有无实现。那么问题又来了，为什么只能对实例方法才能重写？我头好晕，这两个问题在这互相推脱责任。
  理解三个概念：静态类型，实际类型，方法接受者。

Person student= new Student();
student.work();

静态类型就是编译器编译期间认为对象所属的类型，这个主要根据声明类型决定，所以上述Person就是静态类型
实际类型就是解释器在执行时根据引用实际指向的对象所决定的，所以Student就是实际类型。
方法接受者就是动态绑定所找到执行此方法的对象，比如student。

还要理解类编译的class文件中字节码的方法调用指令。
（1）invokestatic：调用静态方法
（2）invokespecial：调用实例构造器方法，私有方法。
（3）invokevirtual：调用所有的虚方法。
（4）invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象。
（5）invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。

非虚方法：不能被重写或者说覆盖的方法，指的是构造方法、静态方法、私有方法和final 修饰的方法。
虚方法：则是能被重写的方法，一般指的是实例方法。

例子

package com.learn.pra06;
class Demo01{
    public void method1(){
        System.out.println("This is father non-static");
    }
    public static void method2(){
        System.out.println("This is father static");
    }
}
public class Demo02 extends Demo01{
    public void method1(){
        System.out.println("This is son non-static");
    }
    public static void method2(){
        System.out.println("This is son static");
    }

    public static void main(String[] args){
        Demo01 d1= new Demo01();
        Demo02 d2= new Demo02();
        Demo01 d3= new Demo02(); //父类引用指向子类对象
        d1.method1();
        d1.method2();
        d2.method1();
        d2.method2();
        d3.method1();
        d3.method2();
    }
}

运行结果：
Java中为什么静态方法不能被重写？为什么静态方法不能隐藏实例方法？
  对于这样的运行结果前5行应该没什么疑问，用常规的思维就能理解，可是最后一条，what?说好的动态绑定呢，Are you kidding me？No,这里没有发生动态绑定了，问题又来了，为什么静态方法不发生动态绑定？动态绑定到底发生了什么？简直是头脑风暴，说实话我也是蒙蒙的，接下来可能正确也可能不正确，但是八九不离十。

分析

首先看看上面main 方法的字节码：

 // access flags 0x9
  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 19 L0
    NEW com/learn/pra06/Demo01
    DUP
    INVOKESPECIAL com/learn/pra06/Demo01.<init> ()V
    ASTORE 1
   L1
    LINENUMBER 20 L1
    NEW com/learn/pra06/Demo02
    DUP
    INVOKESPECIAL com/learn/pra06/Demo02.<init> ()V
    ASTORE 2
   L2
    LINENUMBER 21 L2
    NEW com/learn/pra06/Demo02
    DUP
    INVOKESPECIAL com/learn/pra06/Demo02.<init> ()V
    ASTORE 3
   L3
    LINENUMBER 22 L3
    ALOAD 1
    INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V
   L4
    LINENUMBER 23 L4
    INVOKESTATIC com/learn/pra06/Demo01.method2 ()V
   L5
    LINENUMBER 24 L5
    ALOAD 2
    INVOKEVIRTUAL com/learn/pra06/Demo02.method1 ()V
   L6
    LINENUMBER 25 L6
    INVOKESTATIC com/learn/pra06/Demo02.method2 ()V
   L7
    LINENUMBER 26 L7
    ALOAD 3
    INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V
   L8
    LINENUMBER 27 L8
    INVOKESTATIC com/learn/pra06/Demo01.method2 ()V
   L9
    LINENUMBER 28 L9
    RETURN
   L10

  L+number 对应就是main方法体中每一行，我们可以清晰的看见代码执行的指令，简直大爱，有种相见恨晚的赶脚。
  Demo01 d1= new Demo01();这个语句将会在运行期发生什么呢？结合我们前期准备学的那几个指令集。查看以上的字节码发现：INVOKESPECIAL com/learn/pra06/Demo01.<init> ()V 请问将会调用Demo01的构造函数，这个毋庸置疑。同理L1也是如此。
  Demo01 d3= new Demo02();虽然声明类型为父类，但实际new的时候是子类，同样字节码也对应如此。INVOKESPECIAL com/learn/pra06/Demo02.<init> ()V
  d1.method1();这个语句是应该是对象调用其实例方法，字节码也很好说明了这一点：INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V此处用了INVOKEVIRTUAL，则代表调用虚方法，并且此方法的引用存在方法表中（这个待会再说），只用INVOKEVIRTUAL指令会去方法表寻找要调用方法的引用。
  d1.method2();这句是对象调用静态方法，字节码为：INVOKESTATIC com/learn/pra06/Demo01.method2 ()V此方法则是直接调用方法区中静态方法，无需经过方法表，这也就解释了静态方法的执行只看静态类型，而与实际类型无关，又因为重写的方法调用看的是实际类型，所以静态方法不能被重写。d2的两个方法调用解释与d1相同。
  重点是d3方法的调用过程，d3.method1();字节码：INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V运用了INVOKEVIRTUAL指令，说明运行期间会到方法表中去调用真实指向的方法，因为method01可能被重写，所以编译器期间标明运行时应调用method1所在的方法表中位置存的真正方法的引用。因为method01方法被Demo02重写，所以方法表中原先存父类method01方法的引用被改写成子类的method01方法的引用，所以在运行时根据INVOKEVIRTUAL指令找到的method01的方法是子类的。
  那么d3.method2();通过查看字节码发现：INVOKESTATIC com/learn/pra06/Demo01.method2 ()V用到INVOKESTATIC ，不能访问方法表，而是直接访问的父类的method2的，所以运行时调用就是父类的静态方法。

编译时把对象的静态类型（声明类型）作为该方法的接受者。运行时则根据指令集再进行更改。

INVOKEVIRTUAL指令流程

package com.learn.pra06;
public class ClassReference {
    static class Person {
        @Override
        public String toString(){
            return "I'm a person.";
        }
        public void eat(){
            System.out.println("Person eat");
        }
        public void speak(){
            System.out.println("Person speak");
        }

    }
    static class Boy extends Person{
        @Override
        public String toString(){
            return "I'm a boy";
        }
        @Override
        public void speak(){
            System.out.println("Boy speak");
        }
        public void fight(){
            System.out.println("Boy fight");
        }
    }
    static class Girl extends Person{
        @Override
        public String toString(){
            return "I'm a girl";
        }
        @Override
        public void speak(){
            System.out.println("Girl speak");
        }
        public void sing(){
            System.out.println("Girl sing");
        }
    }
    public static void main(String[] args) {
        Person boy = new Boy();
        Person girl = new Girl();
        System.out.println(boy);
        boy.eat();
        boy.speak();
        System.out.println(girl);
        girl.eat();
        girl.speak();
    }
}

执行结果：
Java中为什么静态方法不能被重写？为什么静态方法不能隐藏实例方法？
  由于Boy 和Girl 没有重写父类Person eat方法，所以会调用父类的eat方法。
字节码：

  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 47 L0
    NEW com/learn/pra06/ClassReference$Boy
    DUP
    INVOKESPECIAL com/learn/pra06/ClassReference$Boy.<init> ()V
    ASTORE 1
   L1
    LINENUMBER 48 L1
    NEW com/learn/pra06/ClassReference$Girl
    DUP
    INVOKESPECIAL com/learn/pra06/ClassReference$Girl.<init> ()V
    ASTORE 2
   L2
    LINENUMBER 49 L2
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L3
    LINENUMBER 50 L3
    ALOAD 1
    INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.eat ()V
   L4
    LINENUMBER 51 L4
    ALOAD 1
    INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.speak ()V
   L5
    LINENUMBER 53 L5
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 2
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L6
    LINENUMBER 54 L6
    ALOAD 2
    INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.eat ()V
   L7
    LINENUMBER 55 L7
    ALOAD 2
    INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.speak ()V
   L8
    LINENUMBER 57 L8
    RETURN
   L9

很明显在L2处，编译器会将根类Object的toString 方法的引用写入class文件，说明编译器会将祖先的方法引用写入，而非近亲。
L3,L4,L6,L7都用到了INVOKEVIRTUAL，到底流程是怎么样的呢？
首先看看方法表在内存的模型：
Java中为什么静态方法不能被重写？为什么静态方法不能隐藏实例方法？
解说图：
1. 首先INVOKEVIRTUAL com/learn/pra06/ClassReferencePerson.speak()V中，根据com/learn/pra06/ClassReference

Person.speak ()V在常量池中找到该方法的偏移量
2. 查看Person的方法表，得到speak方法在该方法表的偏移量（假设为15），这样就得到该方法的直接引用。
3. 根据this判断出该引用指的是Girl实例
4. 然后去找Girl实例的方法表，根据上面的偏移量在方法表中找到该方法引用，因为该方法引用的值在类加载根据是否重写了方法已经确定了正确的方法引用，所以我们这里就可以直接调用该方法。

为什么静态方法不能隐藏实例方法？

静态方法的调用的是通过在编译器静态绑定的，而实例方法的调用是在运行时动态绑定的，2者的调用的方式不同，所以二者只能存在其一，否则会存在歧义！

为什么静态方法能隐藏静态方法？

因为调用方式一致，不会像上面造成歧义，虽然父类和子类都定义了同样的函数，但是编译器会根据对象的静态类型激活对应的静态方法的引用，造成了重写的假象，实则不是重写！

总结

总体流程就是：编译器将类编译成class文件，其中方法会根据静态类型从而将对应的方法引用写入class中，运行时，JVM会根据INVOKEVIRTUAL 所指向的方法引用在常量池找到该方法的偏移量，再根据this找到引用类型真实指向的对象，访问这个对象类型的方法表，根据偏移量找出存放目标方法引用的位置，取出这个引用，调用这个引用实际指向的方法，完成多态

上一篇：conda 环境下 调用 sklearn库 时出现 许多包依赖错误 比如：ImportError: DLL load failed while importing _arpack:


下一篇：python之实现文件的读写