美文网首页
方法重载和重写原理

方法重载和重写原理

作者: 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{
    //
    // }
}

相关文章

网友评论

      本文标题：方法重载和重写原理

      本文链接：https://www.haomeiwen.com/subject/qkbblftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|方法重载和重写原理|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！