方法重载和重写原理

作者: 0x70e8 | 来源:发表于2018-04-27 16:21 被阅读0次

Java的编译不包含传统编译过程的连接阶段，连接是在class加载到JVM中才进行的。Java代码在编译成class文件后，里面所有的方法调用都替换成了符号引用，这些符号引用需要在解析阶段解析成实际的内存地址，也就是直接引用。
JVM提供了5条调用方法的字节码指令：

invokestatic：调用静态方法
invokespecial：调用构造器方法、私有方法
invokevirtual ：调用所有的虚方法
invokeinterface：调用接口方法
invokedynamic ：动态方法调用

重载

看一个简单的代码示例：

 public class OverloadTest {

    void test(int a) {

    }

    void test(String b) {
    }

    public static void main(String[] args) {
        OverloadTest o = new OverloadTest();
        o.test(1);
        o.test("s");
    }
}

反编译：

$ javap -c OverloadTest
警告: 二进制文件OverloadTest包含test.method.OverloadTest
Compiled from "OverloadTest.java"
public class test.method.OverloadTest {
  public test.method.OverloadTest();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  void test(int);
    Code:
       0: return

  void test(java.lang.String);
    Code:
       0: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class test/method/OverloadTest
       3: dup
       4: invokespecial #23                 // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: iconst_1
      10: invokevirtual #24                 // Method test:(I)V
      13: aload_1
      14: ldc           #26                 // String s
      16: invokevirtual #28                 // Method test:(Ljava/lang/String;)V
      19: return
}

可以发现，在编译完成时，重载方法的两次调用分别是：

invokevirtual #24                 // Method test:(I)V
invokevirtual #28                 // Method test:(Ljava/lang/String;)V

也就是方法版本（签名）已经确定 .
再一个涉及继承的重载示例：

public class OverloadTest2 {

    static class Super {

    }

    static class Sub extends Super {

    }

    static void test(Super s) {
        System.out.println("super");
    }

    static void test(Sub s) {
        System.out.println("sub");
    }

    public static void main(String[] args) {
        Super s = new Super();
        test(s);
        s = new Sub();
        test(s);
        Sub sub = new Sub();
        test(sub);
    }
}

反编译：

$ javap -c OverloadTest2
警告: 二进制文件OverloadTest2包含test.method.OverloadTest2
Compiled from "OverloadTest2.java"
public class test.method.OverloadTest2 {
  public test.method.OverloadTest2();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  static void test(test.method.OverloadTest2$Super);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #22                 // String super
       5: invokevirtual #24                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  static void test(test.method.OverloadTest2$Sub);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #33                 // String sub
       5: invokevirtual #24                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #38                 // class test/method/OverloadTest2$Super
       3: dup
       4: invokespecial #40                 // Method test/method/OverloadTest2$Super."<init>":()V
       7: astore_1
       8: aload_1
       9: invokestatic  #41                 // Method test:(Ltest/method/OverloadTest2$Super;)V
      12: new           #43                 // class test/method/OverloadTest2$Sub
      15: dup
      16: invokespecial #45                 // Method test/method/OverloadTest2$Sub."<init>":()V
      19: astore_1
      20: aload_1
      21: invokestatic  #41                 // Method test:(Ltest/method/OverloadTest2$Super;)V
      24: new           #43                 // class test/method/OverloadTest2$Sub
      27: dup
      28: invokespecial #45                 // Method test/method/OverloadTest2$Sub."<init>":()V
      31: astore_2
      32: aload_2
      33: invokestatic  #46                 // Method test:(Ltest/method/OverloadTest2$Sub;)V
      36: return
}

对应关系：

        Super s = new Super();
        test(s);                //9: invokestatic  #41                 // Method test:(Ltest/method/OverloadTest2$Super;)V
        s = new Sub();
        test(s);                //21: invokestatic  #41                 // Method test:(Ltest/method/OverloadTest2$Super;)V
        Sub sub = new Sub();
        test(sub);              //33: invokestatic  #46                 // Method test:(Ltest/method/OverloadTest2$Sub;)V

和上面的一样，在编译期确定了方法的版本。可以看出，Java在实现重载时，是使用静态选择的，为什么这么说呢，因为在编译期，要调用哪个重载方法已经确定下来了（看字节码就知道已经定下来了，为什么要在这个时候定下来，设计如此），另外在选择方法时，是依据对象的声明类型来绑定方法的，实际上为了在编译期确定方法，也只能通过对象的声明类型即静态类型，因为动态类型编译器也不知道啊。

重写

public class OverrideTest {
    static class Super {
        void test() {
            System.out.println("super method");
        }
    }

    static class Sub extends Super {
        void test() {
            System.out.println("sub method");

        }
    }

    public static void main(String[] args) {
        Super s = new Super();
        s.test(); //super method
        s = new Sub();
        s.test(); // sub method
    }
}

反编译：

$ javap -c OverrideTest
警告: 二进制文件OverrideTest包含test.method.OverrideTest
Compiled from "OverrideTest.java"
public class test.method.OverrideTest {
  public test.method.OverrideTest();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #16                 // class test/method/OverrideTest$Super
       3: dup
       4: invokespecial #18                 // Method test/method/OverrideTest$Super."<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #19                 // Method test/method/OverrideTest$Super.test:()V
      12: new           #22                 // class test/method/OverrideTest$Sub
      15: dup
      16: invokespecial #24                 // Method test/method/OverrideTest$Sub."<init>":()V
      19: astore_1
      20: aload_1
      21: invokevirtual #19                 // Method test/method/OverrideTest$Super.test:()V
      24: return
}

源码和字节码指令对应：

    Super s = new Super();
    s.test();     //9: invokevirtual #19                 // Method test/method/OverrideTest$Super.test:()V
    s = new Sub();//21: invokevirtual #19                 // Method test/method/OverrideTest$Super.test:()V
    s.test();

和重载一样，对应方法的签名在编译期也是确定的，当然是根据静态类型来确定的。那么最后怎么就进入了子类重写的方法呢？
这就要看一下invokevirtual指令的逻辑了：

If the resolved method is not signature polymorphic (§2.9), then the invokevirtual instruction proceeds as follows.
Let C be the class of objectref. The actual method to be invoked is selected by the following lookup procedure:
• If C contains a declaration for an instance method m that overrides (§5.4.5) the resolved method, then m is the method to be invoked, and the lookup procedure terminates.
• Otherwise, if C has a superclass, this same lookup procedure is performed recursively using the direct superclass of C; the method to be invoked is the result of the recursive invocation of
this lookup procedure.
• Otherwise, an AbstractMethodError is raised.
（未涉及同步和native方法的lookup逻辑）

也就是先在本类中找此签名的方法，没找到就去父类递归寻找，如果一直找不到，就抛异常。

所以方法签名在编译期确定，具体调用子类还是父类的方法，得看接受者的实际类型，得在运行期确定。

重写的注意点

子类方法的访问权限不得小于父类
子类抛出的异常不能比父类抽象
这两个限制是为了兼容里式替换原则(Liskov Substitution Principle LSP)。

里式替换原则
任何基类可以出现的地方，子类一定可以出现。

子类不能重写父类私有和静态方法 -> 可以在子类写，但是不是重写的效果，因为是私有的（实例私有和类私有，方法的确认过程上面已经说的很清楚了）

class Super {
    static void a() {
    }

    final private void run() {
        System.out.println("super");
    }

    public void b() {

    }

    public void c() throws IOException {

    }
}

class Sub extends Super {
    // 不是重写，是Class持有的
    static void a() {
    }

    // 不是重写，是自己私有的
    final private void run() {
        System.out.println("sub");
    }
    // void b(){ 错误，不能比父类的访问权限低
    //
    // }
    // 不能比父类方法抛出的异常范围更大
    // public void c()throws Exception{
    //
    // }
}

方法重载和重写原理

重载

重写

重写的注意点

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读