[java] 자바 : 재정의 된 메서드를 호출하는 슈퍼 메서드 호출

이렇게 생각해

+----------------+
|     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수퍼 클래스에서 사용 하는 경우 수 퍼듀 퍼 클래스 [조부모]에서 코드가 실행되는 반면, 수퍼 클래스에서 사용 this(또는 암시 적으로 사용되는 경우)하면 하위 클래스를 계속 가리 킵니다 (아무도 변경하지 않았기 때문에-그리고 아무도 할 수 있었다).

답변

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");
  }
}

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

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