Java：调用超级方法，该方法调用被重写的方法

Question

public class SuperClass
{
    public void method1()
    {
        System.out.println("superclass method1");
        this.method2();
    }

    public void method2()
    {
        System.out.println("superclass method2");
    }

}

public class SubClass extends SuperClass
{
    @Override
    public void method1()
    {
        System.out.println("subclass method1");
        super.method1();
    }

    @Override
    public void method2()
    {
        System.out.println("subclass method2");
    }
}



public class Demo 
{
    public static void main(String[] args) 
    {
        SubClass mSubClass = new SubClass();
        mSubClass.method1();
    }
}

我的预期输出：

子类方法1
超类方法1
超类方法2

实际输出：

子类方法1
超类方法1
子类方法2

我知道从技术上讲我已经重写了一个公共方法，但我认为因为我正在调用超级方法，所以超级中的任何调用都会保留在超级中，这不会发生。关于如何实现它有什么想法吗？

Answer 1

关键字 super 不会“粘住”。每个方法调用都是单独处理的，因此即使您通过调用 super 到达 SuperClass.method1()，也不会影响您可能进行的任何其他方法调用未来。

这意味着没有直接方法可以从 SuperClass.method1() 调用 SuperClass.method2() 而无需通过 SubClass.method2() 除非您正在使用 SuperClass 的实际实例。

您甚至无法使用反射达到预期的效果（请参见java.lang.reflect.Method.invoke(Object, Object...) 的文档 ）。

[编辑]似乎仍然有些混乱。让我尝试一个不同的解释。

当您调用 foo() 时，您实际上调用了 this.foo()。 Java 只是让您省略 this。在问题的示例中，this 的类型是 SubClass。

所以当Java执行SuperClass.method1()中的代码时，最终会到达this.method2();，

使用super并不会改变this 指向的实例。因此，调用会转到 SubClass.method2()，因为 this 的类型为 SubClass。

当您想象 Java 将 this 作为隐藏的第一个参数传递时，也许更容易理解：

public class SuperClass
{
    public void method1(SuperClass this)
    {
        System.out.println("superclass method1");
        this.method2(this); // <--- this == mSubClass
    }

    public void method2(SuperClass this)
    {
        System.out.println("superclass method2");
    }

}

public class SubClass extends SuperClass
{
    @Override
    public void method1(SubClass this)
    {
        System.out.println("subclass method1");
        super.method1(this);
    }

    @Override
    public void method2(SubClass this)
    {
        System.out.println("subclass method2");
    }
}



public class Demo 
{
    public static void main(String[] args) 
    {
        SubClass mSubClass = new SubClass();
        mSubClass.method1(mSubClass);
    }
}

如果您跟踪调用堆栈，您可以看到 this 永远不会改变，它始终是在 main() 中创建的实例。

Answer 2

您只能在重写方法（或重写类的其他方法）中访问重写方法。

因此：要么不要重写 method2() ，要么在重写的版本中调用 super.method2() 。

Answer 3

我是这样想的

+----------------+
|     super      |
+----------------+ <-----------------+
| +------------+ |                   |
| |    this    | | <-+               |
| +------------+ |   |               |
| | @method1() | |   |               |
| | @method2() | |   |               |
| +------------+ |   |               |
|    method4()   |   |               |
|    method5()   |   |               |
+----------------+   |               |
    We instantiate that class, not that one!

让我将该子类向左移动一点以显示下面的内容......
（伙计，我确实喜欢 ASCII 图形）

We are here
        |
       /  +----------------+
      |   |     super      |
      v   +----------------+
+------------+             |
|    this    |             |
+------------+             |
| @method1() | method1()   |
| @method2() | method2()   |
+------------+ method3()   |
          |    method4()   |
          |    method5()   |
          +----------------+

Then we call the method
over here...
      |               +----------------+
 _____/               |     super      |
/                     +----------------+
|   +------------+    |    bar()       |
|   |    this    |    |    foo()       |
|   +------------+    |    method0()   |
+-> | @method1() |--->|    method1()   | <------------------------------+
    | @method2() | ^  |    method2()   |                                |
    +------------+ |  |    method3()   |                                |
                   |  |    method4()   |                                |
                   |  |    method5()   |                                |
                   |  +----------------+                                |
                   \______________________________________              |
                                                          \             |
                                                          |             |
...which calls super, thus calling the super's method1() here, so that that
method (the overidden one) is executed instead[of the overriding one].

Keep in mind that, in the inheritance hierarchy, since the instantiated
class is the sub one, for methods called via super.something() everything
is the same except for one thing (two, actually): "this" means "the only
this we have" (a pointer to the class we have instantiated, the
subclass), even when java syntax allows us to omit "this" (most of the
time); "super", though, is polymorphism-aware and always refers to the
superclass of the class (instantiated or not) that we're actually
executing code from ("this" is about objects [and can't be used in a
static context], super is about classes).

换句话说，引用 Java 语言规范：

super.Identifier 形式指的是名为 Identifier 的字段
当前对象，但将当前对象视为
当前类的超类。

T.super.Identifier 形式指的是名为 Identifier 的字段
对应于 T 的词法封闭实例，但是这样
实例被视为 T 超类的实例。

通俗地说，this 基本上是一个对象（*the** 对象；您可以在变量中移动的同一对象）、实例化类的实例、数据域中的普通变量； super 就像一个指向要执行的借用代码块的指针，更像是一个纯粹的函数调用，并且它与调用它的类相关。

因此，如果您从超类中使用 super ，您将从执行的 superduper 类（祖父母）中获取代码），而如果您使用 this （或者如果它是隐式使用的）超类它一直指向子类（因为没有人改变它 - 没有人可以）。

Answer 4

您使用的 this 关键字实际上指的是“您正在使用的对象的当前运行实例”，也就是说，您正在调用 this.method2(); 在你的超类上，也就是说，它将在你正在使用的对象（即子类）上调用 method2() 。

Answer 5

如果您不希望 superClass.method1 调用 subClass.method2，请将 method2 设置为私有，这样它就无法被覆盖。

这里有一个建议：

public class SuperClass {

  public void method1() {
    System.out.println("superclass method1");
    this.internalMethod2();
  }

  public void method2()  {
    // this method can be overridden.  
    // It can still be invoked by a childclass using super
    internalMethod2();
  }

  private void internalMethod2()  {
    // this one cannot.  Call this one if you want to be sure to use
    // this implementation.
    System.out.println("superclass method2");
  }

}

public class SubClass extends SuperClass {

  @Override
  public void method1() {
    System.out.println("subclass method1");
    super.method1();
  }

  @Override
  public void method2() {
    System.out.println("subclass method2");
  }
}

如果它不以这种方式工作，多态性将是不可能的（或者至少没有一半有用）。

Answer 6

class SuperClass
{
    public void method1()
    {
        System.out.println("superclass method1");
        SuperClass se=new SuperClass();
        se.method2();
    }

    public void method2()
    {
        System.out.println("superclass method2");
    }
}


class SubClass extends SuperClass
{
    @Override
    public void method1()
    {
        System.out.println("subclass method1");
        super.method1();
    }

    @Override
    public void method2()
    {
        System.out.println("subclass method2");
    }
}

调用

SubClass mSubClass = new SubClass();
mSubClass.method1();

输出

子类方法1
超类方法1
超类方法2

Answer 7

由于避免方法被重写的唯一方法是使用关键字 super，因此我考虑将 method2() 从 SuperClass 移至另一个新的 >Base 类，然后从 SuperClass 调用它：

class Base 
{
    public void method2()
    {
        System.out.println("superclass method2");
    }
}

class SuperClass extends Base
{
    public void method1()
    {
        System.out.println("superclass method1");
        super.method2();
    }
}

class SubClass extends SuperClass
{
    @Override
    public void method1()
    {
        System.out.println("subclass method1");
        super.method1();
    }

    @Override
    public void method2()
    {
        System.out.println("subclass method2");
    }
}

public class Demo 
{
    public static void main(String[] args) 
    {
        SubClass mSubClass = new SubClass();
        mSubClass.method1();
    }
}

输出：

subclass method1
superclass method1
superclass method2

Answer 8

this 始终引用当前正在执行的对象。

为了进一步说明这一点，这里有一个简单的草图：

+----------------+
|  Subclass      |
|----------------|
|  @method1()    |
|  @method2()    |
|                |
| +------------+ |
| | Superclass | |
| |------------| |
| | method1()  | |
| | method2()  | |
| +------------+ |
+----------------+

如果您有一个外部盒子的实例，一个 Subclass 对象，无论您碰巧在盒子内部冒险，甚至进入 Superclass 对象， code>'area'，仍然是外框的实例。

更重要的是，在这个程序中，三个类中只有一个对象被创建，因此 this 只能引用一个东西，它是：

如图所示在 Netbeans“Heap Walker”中。

Answer 9

我不相信你能直接做到这一点。一种解决方法是在超类中拥有 method2 的私有内部实现，并调用它。例如：

public class SuperClass
{
    public void method1()
    {
        System.out.println("superclass method1");
        this.internalMethod2();
    }

    public void method2()
    {
        this.internalMethod2(); 
    }
    private void internalMethod2()
    {
        System.out.println("superclass method2");
    }

}

Answer 10

“this”关键字指的是当前类引用。这意味着，当它在方法内部使用时，“当前”类仍然是 SubClass，因此，答案得到了解释。

Answer 11

总而言之，this指向当前对象，java中的方法调用本质上是多态的。因此，执行方法的选择完全取决于 this 指向的对象。因此，从父类调用方法method2()会调用子类的method2()，因为this指向子类的对象。无论使用哪个类，它的定义都不会改变。

附言。与方法不同，类的成员变量不是多态的。

Answer 12

在我对类似案例的研究过程中，我最终通过检查子类方法中的堆栈跟踪来找出调用的来源。可能有更聪明的方法可以做到这一点，但这对我来说很有效，而且是一种动态方法。

public void method2(){
        Exception ex=new Exception();
        StackTraceElement[] ste=ex.getStackTrace();
        if(ste[1].getClassName().equals(this.getClass().getSuperclass().getName())){
            super.method2();
        }
        else{
            //subclass method2 code
        }
}

我认为对案件提出解决方案的问题是合理的。当然，有多种方法可以使用不同的方法名称甚至不同的参数类型来解决问题，就像线程中已经提到的那样，但就我而言，我不喜欢通过不同的方法名称来混淆。

Answer 13

进一步扩展所提出问题的输出，这将使您对访问说明符和覆盖行为有更多的了解。

            package overridefunction;
            public class SuperClass 
                {
                public void method1()
                {
                    System.out.println("superclass method1");
                    this.method2();
                    this.method3();
                    this.method4();
                    this.method5();
                }
                public void method2()
                {
                    System.out.println("superclass method2");
                }
                private void method3()
                {
                    System.out.println("superclass method3");
                }
                protected void method4()
                {
                    System.out.println("superclass method4");
                }
                void method5()
                {
                    System.out.println("superclass method5");
                }
            }

            package overridefunction;
            public class SubClass extends SuperClass
            {
                @Override
                public void method1()
                {
                    System.out.println("subclass method1");
                    super.method1();
                }
                @Override
                public void method2()
                {
                    System.out.println("subclass method2");
                }
                // @Override
                private void method3()
                {
                    System.out.println("subclass method3");
                }
                @Override
                protected void method4()
                {
                    System.out.println("subclass method4");
                }
                @Override
                void method5()
                {
                    System.out.println("subclass method5");
                }
            }

            package overridefunction;
            public class Demo 
            {
                public static void main(String[] args) 
                {
                    SubClass mSubClass = new SubClass();
                    mSubClass.method1();
                }
            }

            subclass method1
            superclass method1
            subclass method2
            superclass method3
            subclass method4
            subclass method5