왜 super.super.method (); 자바에서는 허용되지 않습니까?

이 질문을 읽고 글을 쓸 수 있다면 쉽게 해결할 수 있다고 생각했습니다 (없이 해결할 수는 없음).

@Override
public String toString() {
    return super.super.toString();
}

나는 그것이 많은 경우에 유용한 지 잘 모르겠지만 왜 그것이 그렇지 않은지 궁금 하고 다른 언어로 이런 것이 존재 하는지 궁금 합니다.

너희들은 어떻게 생각하니?

편집 : 명확하게 : 네, 알고 있습니다 .Java에서는 불가능하며 실제로 놓치지 않습니다. 이것은 내가 작동 할 것으로 예상되는 것이 아니며 컴파일러 오류가 발생하는 것에 놀랐습니다. 방금 아이디어가 있었고 토론하고 싶습니다.

캡슐화를 위반합니다. 부모 클래스의 행동을 우회해서는 안됩니다. 부모님이 아닌 자신의 클래스의 행동 (특히 같은 방법 내에서) 을 우회 할 수있는 경우가 있습니다 . 예를 들어, 기본 "항목 모음", "빨간색 항목 모음"을 나타내는 하위 클래스 및 "큰 빨간색 항목 모음"을 나타내는 하위 클래스가 있다고 가정합니다. 다음을 갖는 것이 합리적입니다.

public class Items
{
    public void add(Item item) { ... }
}

public class RedItems extends Items
{
    @Override
    public void add(Item item)
    {
        if (!item.isRed())
        {
            throw new NotRedItemException();
        }
        super.add(item);
    }
}

public class BigRedItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        if (!item.isBig())
        {
            throw new NotBigItemException();
        }
        super.add(item);
    }
}

좋습니다. RedItems는 항상 포함 된 항목이 모두 빨간색임을 확신 할 수 있습니다. 이제 우리는 생각 했다 super.super.add ()를 호출 할 수 :

public class NaughtyItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        // I don't care if it's red or not. Take that, RedItems!
        super.super.add(item);
    }
}

이제 우리는 원하는 것을 추가 할 수 있고 RedItems 은 깨졌습니다.

말이 돼?

Jon Skeet이 정답이라고 생각합니다. 캐스팅을 통해 수퍼 클래스의 수퍼 클래스에서 음영 처리 된 변수에 액세스 할 수 있다고 덧붙이고 싶습니다 this.

interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
        int x = 3;
        void test() {
                System.out.println("x=\t\t"          + x);
                System.out.println("super.x=\t\t"    + super.x);
                System.out.println("((T2)this).x=\t" + ((T2)this).x);
                System.out.println("((T1)this).x=\t" + ((T1)this).x);
                System.out.println("((I)this).x=\t"  + ((I)this).x);
        }
}

class Test {
        public static void main(String[] args) {
                new T3().test();
        }
}

출력을 생성합니다.

x = 3
super.x = 2
((T2) this) .x = 2
((T1) this) .x = 1
((I) this) .x = 0

( JLS의 예 )

그러나 메서드 호출은 개체의 런타임 유형에 따라 결정되므로 메서드 호출에는 작동하지 않습니다.

다음 코드는 대부분의 경우 super.super ... super.method ()를 사용할 수 있다고 생각합니다. (추천하지 않더라도)

한마디로

1. 조상 유형의 임시 인스턴스 생성
2. 원래 객체에서 임시 객체로 필드 값 복사
3. 임시 객체에서 대상 메소드 호출
4. 수정 된 값을 원래 객체로 다시 복사

사용법 :

public class A {
   public void doThat() { ... }
}

public class B extends A {
   public void doThat() { /* don't call super.doThat() */ }
}

public class C extends B {
   public void doThat() {
      Magic.exec(A.class, this, "doThat");
   }
}


public class Magic {
    public static <Type, ChieldType extends Type> void exec(Class<Type> oneSuperType, ChieldType instance,
            String methodOfParentToExec) {
        try {
            Type type = oneSuperType.newInstance();
            shareVars(oneSuperType, instance, type);
            oneSuperType.getMethod(methodOfParentToExec).invoke(type);
            shareVars(oneSuperType, type, instance);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    private static <Type, SourceType extends Type, TargetType extends Type> void shareVars(Class<Type> clazz,
            SourceType source, TargetType target) throws IllegalArgumentException, IllegalAccessException {
        Class<?> loop = clazz;
        do {
            for (Field f : loop.getDeclaredFields()) {
                if (!f.isAccessible()) {
                    f.setAccessible(true);
                }
                f.set(target, f.get(source));
            }
            loop = loop.getSuperclass();
        } while (loop != Object.class);
    }
}

의견이 충분하지 않아 다른 답변에 추가 할 것입니다.

Jon Skeet은 아름다운 예를 들어 훌륭하게 대답합니다. Matt B는 요점을 가지고 있습니다. 모든 수퍼 클래스에 수퍼 클래스가있는 것은 아닙니다. 수퍼가없는 수퍼의 수퍼를 호출하면 코드가 손상됩니다.

객체 지향 프로그래밍 (Java)은 함수가 아니라 객체에 관한 것입니다. 작업 지향 프로그래밍을 원한다면 C ++ 또는 다른 것을 선택하십시오. 객체가 수퍼 클래스에 맞지 않으면 "조부모 클래스"에 추가하거나 새 클래스를 만들거나 다른 수퍼 클래스를 찾아야합니다.

개인적으로, 나는이 제한이 Java의 가장 큰 강점 중 하나라는 것을 알았습니다. 코드는 내가 사용한 다른 언어에 비해 다소 엄격하지만 항상 기대할 사항을 알고 있습니다. 이는 Java의 "단순하고 친숙한"목표에 도움이됩니다. 내 마음에, super.super를 호출하는 것은 간단하거나 친숙하지 않습니다. 아마도 개발자들은 같은 느낌을 받았습니까?

이를 수행해야 할 몇 가지 이유가 있습니다. 잘못 구현 된 메소드가있는 서브 클래스가있을 수 있지만 상위 메소드가 올바르게 구현되었습니다. 타사 라이브러리에 속하기 때문에 소스를 변경하지 않거나 원하지 않을 수 있습니다. 이 경우 서브 클래스를 작성하지만 하나의 메소드를 대체하여 super.super 메소드를 호출하려고합니다.

다른 포스터에서 볼 수 있듯이 반사를 통해이 작업을 수행 할 수 있지만 다음과 같은 작업을 수행 할 수 있어야합니다

(SuperSuperClass this) .theMethod ();

나는이 문제를 지금 다루고 있습니다-빠른 수정은 수퍼 클래스 메소드를 복사하여 서브 서브 클래스 메소드에 붙여 넣는 것입니다 :)

다른 사람들이 만든 좋은 점 외에도 다른 이유가 있다고 생각합니다. 슈퍼 클래스에 슈퍼 클래스가 없으면 어떻게됩니까?

모든 클래스는 자연적으로 (적어도) 확장 때문에 Object, super.whatever()항상 슈퍼 클래스의 메소드를 참조합니다. 당신의 클래스는 확장한다면 어떻게 Object- 무엇을 할 super.super다음을 참조하십시오? 컴파일러 오류, NullPointer 등의 동작을 어떻게 처리해야합니까?

이것이 허용되지 않는 주된 이유는 캡슐화를 위반하기 때문이지만 이것이 작은 이유 일 수 있다고 생각합니다.

메서드를 덮어 쓰고 모든 수퍼 클래스 버전 (예 :와 같이 equals)을 원한다면 사실상 직접 수퍼 클래스 버전을 먼저 호출하고 싶습니다. 원하는 경우 수퍼 클래스 버전을 차례로 호출합니다. .

나는 임의의 수퍼 클래스 버전의 메소드를 호출하는 것이 거의 의미가 없다고 생각한다. Java에서 이것이 가능한지 모르겠습니다. C ++에서 수행 할 수 있습니다.

this->ReallyTheBase::foo();

자주 사용되지 않기 때문에 추측합니다. 내가 그것을 볼 수있는 유일한 이유는 직계 부모가 일부 기능을 재정의하고 원래 기능으로 다시 복원하려고하기 때문입니다.

클래스의 직계 부모는 조부모보다 클래스와 더 밀접하게 관련되어야하기 때문에 OO 원칙에 위배되는 것으로 보입니다.

봐 이 Github의 프로젝트, 특히 objectHandle 변수입니다. 이 프로젝트는 손자에서 조부모 메서드를 실제로 정확하고 호출하는 방법을 보여줍니다.

링크가 끊어 질 경우를 대비하여 코드는 다음과 같습니다.

import lombok.val;
import org.junit.Assert;
import org.junit.Test;

import java.lang.invoke.*;

/*
Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.
Please don't actually do this... :P
*/
public class ImplLookupTest {
    private MethodHandles.Lookup getImplLookup() throws NoSuchFieldException, IllegalAccessException {
        val field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
        field.setAccessible(true);
        return (MethodHandles.Lookup) field.get(null);
    }

    @Test
    public void test() throws Throwable {
        val lookup = getImplLookup();
        val baseHandle = lookup.findSpecial(Base.class, "toString",
            MethodType.methodType(String.class),
            Sub.class);
        val objectHandle = lookup.findSpecial(Object.class, "toString",
            MethodType.methodType(String.class),
            // Must use Base.class here for this reference to call Object's toString
            Base.class);
        val sub = new Sub();
        Assert.assertEquals("Sub", sub.toString());
        Assert.assertEquals("Base", baseHandle.invoke(sub));
        Assert.assertEquals(toString(sub), objectHandle.invoke(sub));
    }

    private static String toString(Object o) {
        return o.getClass().getName() + "@" + Integer.toHexString(o.hashCode());
    }

    public class Sub extends Base {
        @Override
        public String toString() {
            return "Sub";
        }
    }

    public class Base {
        @Override
        public String toString() {
            return "Base";
        }
    }
}

행복한 코딩 !!!!

가능한 경우 super.super 메소드 본문을 다른 메소드에 넣을 것입니다.

class SuperSuperClass {
    public String toString() {
        return DescribeMe();
    }

    protected String DescribeMe() {
        return "I am super super";
    }
}

class SuperClass extends SuperSuperClass {
    public String toString() {
        return "I am super";
    }
}

class ChildClass extends SuperClass {
    public String toString() {
        return DescribeMe();
    }
}

또는 수퍼 수퍼 클래스를 변경할 수 없으면 다음을 시도하십시오.

class SuperSuperClass {
    public String toString() {
        return "I am super super";
    }
}

class SuperClass extends SuperSuperClass {
    public String toString() {
        return DescribeMe(super.toString());
    }

    protected String DescribeMe(string fromSuper) {
        return "I am super";
    }
}

class ChildClass extends SuperClass {
    protected String DescribeMe(string fromSuper) {
        return fromSuper;
    }
}

두 경우 모두

new ChildClass().toString();

"나는 슈퍼 슈퍼"결과

리플렉션을 사용하여 적어도 수퍼 클래스의 수퍼 클래스의 클래스를 가져 오는 것이 가능할 것 같습니다. 이것이 유용한 경우 http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass () 에서 Javadoc을 고려하십시오.

public class A {

     @Override
     public String toString() {
          return "A";
     }

}


public class B extends A {

     @Override
     public String toString() {
          return "B";
     }

}

public class C extends B {

     @Override
     public String toString() {
          return "C";
     }

}


public class D extends C {

     @Override
     public String toString() {
          String result = "";
          try {
                result = this.getClass().getSuperclass().getSuperclass().getSuperclass().newInstance().toString();
          } catch (InstantiationException ex) {
                Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
          } catch (IllegalAccessException ex) {
                Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
          }
          return result;
     }

}

public class Main {

     public static void main(String... args) {
          D d = new D();
          System.out.println(d);

     }
}

실행 : BUILD SUCCESSFUL (총 시간 : 0 초)

기본 클래스의 코드를 변경할 수없는 경우 super.super.method () 호출이 의미가 있습니다. 기존 라이브러리를 확장 할 때 종종 발생합니다.

먼저 스스로에게 물어보십시오. 왜 수업을 확장합니까? 대답이 "변경할 수 없기 때문에"인 경우 응용 프로그램에서 정확한 패키지 및 클래스를 만들고 잘못된 메서드를 다시 작성하거나 대리인을 만들 수 있습니다.

package com.company.application;

public class OneYouWantExtend extends OneThatContainsDesiredMethod {

    // one way is to rewrite method() to call super.method() only or 
    // to doStuff() and then call super.method()

    public void method() {
        if (isDoStuff()) {
            // do stuff
        }
        super.method();
    }

    protected abstract boolean isDoStuff();


    // second way is to define methodDelegate() that will call hidden super.method()

    public void methodDelegate() {
        super.method();
    }
    ...
}

public class OneThatContainsDesiredMethod {

    public void method() {...}
    ...
}

예를 들어, 응용 프로그램에서 org.springframework.test.context.junit4.SpringJUnit4ClassRunner 클래스를 만들 수 있으므로 jar에서 실제 클래스보다 먼저이 클래스를로드해야합니다. 그런 다음 메소드 또는 생성자를 다시 작성하십시오.

주의 : 이것은 절대적인 해킹이므로 사용하지 않는 것이 좋지만 작동 중입니다! 이 방법의 사용은 클래스 로더에 가능한 문제 때문에 위험합니다. 또한 덮어 쓴 클래스가 포함 된 라이브러리를 업데이트 할 때마다 문제가 발생할 수 있습니다.

아키텍처가 여러 파생 클래스 대신 구현되는 공통 CustomBaseClass에서 공통 기능을 빌드하는 경우와 같은 상황이 있습니다. 그러나 특정 파생 클래스의 특정 메서드에 대한 공통 논리를 우회해야합니다. 이러한 경우 super.super.methodX 구현을 사용해야합니다.

우리는 CustomBaseClass에 boolean 멤버를 도입하여이를 구현합니다. 이는 커스텀 구현을 선택적으로 지연시키고 원하는 경우 기본 프레임 워크 구현을 생성하는 데 사용할 수 있습니다.

        ...
        FrameworkBaseClass (....) extends...
        {
           methodA(...){...}
           methodB(...){...}
        ...
           methodX(...)
        ...
           methodN(...){...}

        }
        /* CustomBaseClass overrides default framework functionality for benefit of several derived classes.*/
        CustomBaseClass(...) extends FrameworkBaseClass 
        {
        private boolean skipMethodX=false; 
        /* implement accessors isSkipMethodX() and setSkipMethodX(boolean)*/

           methodA(...){...}
           methodB(...){...}
        ...
           methodN(...){...}

           methodX(...){
                  if (isSkipMethodX()) {
                       setSKipMethodX(false);
                       super.methodX(...);
                       return;
                       }
                   ... //common method logic
            }
        }

        DerivedClass1(...) extends CustomBaseClass
        DerivedClass2(...) extends CustomBaseClass 
        ...
        DerivedClassN(...) extends CustomBaseClass...

        DerivedClassX(...) extends CustomBaseClass...
        {
           methodX(...){
                  super.setSKipMethodX(true);
                  super.methodX(...);
                       }
        }

그러나 프레임 워크와 앱에서 좋은 아키텍처 원칙을 준수하면 isA 방식 대신 hasA 방식을 사용하여 이러한 상황을 쉽게 피할 수 있습니다. 그러나 항상 제대로 설계된 아키텍처를 기대하는 것은 그리 실용적이지 않으므로 견고한 디자인 원칙에서 벗어나 이와 같은 핵을 도입해야 할 필요성이 있습니다. 내 2 센트 만 ...

@ Jon Skeet 좋은 설명입니다. 누군가가 super.super 메소드를 호출하려는 경우 IMO는 직계 부모의 행동을 무시하고 싶지만 할아버지의 부모 행동에 액세스하려고합니다. 이는 인스턴스 Of를 통해 달성 할 수 있습니다. 아래 코드와 같이

public class A {
    protected void printClass() {
        System.out.println("In A Class");
    }
}

public class B extends A {

    @Override
    protected void printClass() {
        if (!(this instanceof C)) {
            System.out.println("In B Class");
        }
        super.printClass();
    }
}

public class C extends B {
    @Override
    protected void printClass() {
        System.out.println("In C Class");
        super.printClass();
    }
}

여기 드라이버 클래스가 있습니다.

public class Driver {
    public static void main(String[] args) {
        C c = new C();
        c.printClass();
    }
}

이것의 출력은

In C Class
In A Class

이 경우 클래스 B printClass 동작은 무시됩니다. 이것이 super.super를 달성하기위한 이상적인 또는 좋은 방법인지 확실하지 않지만 여전히 작동합니다.

슈퍼 클래스가 필요하다고 생각되면 해당 클래스의 변수에서 슈퍼 클래스를 참조 할 수 있습니다. 예를 들면 다음과 같습니다.

public class Foo
{
  public int getNumber()
  {
    return 0;
  }
}

public class SuperFoo extends Foo
{
  public static Foo superClass = new Foo();
  public int getNumber()
  {
    return 1;
  }
}

public class UltraFoo extends Foo
{
  public static void main(String[] args)
  {
    System.out.println(new UltraFoo.getNumber());
    System.out.println(new SuperFoo().getNumber());
    System.out.println(new SuperFoo().superClass.getNumber());
  }
  public int getNumber()
  {
    return 2;
  }
}

인쇄해야합니다 :

2
1
0

IMO super.super.sayYourName()는 Java에서 동작 을 수행하는 깔끔한 방법 입니다.

public class GrandMa {  
    public void sayYourName(){  
        System.out.println("Grandma Fedora");  
    }  
}  

public class Mama extends GrandMa {  
    public void sayYourName(boolean lie){  
        if(lie){   
            super.sayYourName();  
        }else {  
            System.out.println("Mama Stephanida");  
        }  
    }  
}  

public class Daughter extends Mama {  
    public void sayYourName(boolean lie){  
        if(lie){   
            super.sayYourName(lie);  
        }else {  
            System.out.println("Little girl Masha");  
        }  
    }  
}  

public class TestDaughter {
    public static void main(String[] args){
        Daughter d = new Daughter();

        System.out.print("Request to lie: d.sayYourName(true) returns ");
        d.sayYourName(true);
        System.out.print("Request not to lie: d.sayYourName(false) returns ");
        d.sayYourName(false);
    }
}

산출:

Request to lie: d.sayYourName(true) returns Grandma Fedora
Request not to lie: d.sayYourName(false) returns Little girl Masha

이것이 상속 상속 계약을 위반하는 문제라고 생각합니다. 전화 를 걸 때
자신의 행동, 복종, 행동에 복종 / 동의하는 수업을 확장함으로써 자신의 복종 계약을 위반하고 싶을 것입니다.
super.super.method()

당신은 슈퍼 클래스에서 체리를 선택할 수 없습니다 .

그러나 호출해야 할 필요가 있다고 생각되는 상황이 발생할 수 있습니다. super.super.method()일반적으로 잘못된 디자인 부호, 코드 또는 상속 한 코드에 있습니다! 슈퍼 와 슈퍼 슈퍼
라면 클래스는 다음 상속을 통해 구성을 선택, (일부 레거시 코드)를 리팩토링 할 수 없습니다.

캡슐화 끊기는 캡슐화 된 코드를 깨뜨려 일부 메소드 를 오버라이드 할 때 입니다. 재정의되지 않도록 설계된 방법은 final 로 표시 됩니다.

C #에서는 다음과 같은 조상의 메소드를 호출 할 수 있습니다.

public class A
    internal virtual void foo()
...
public class B : A
    public new void foo()
...
public class C : B
    public new void foo() {
       (this as A).foo();
    }

또한 당신은 델파이에서 이것을 할 수 있습니다 :

type
   A=class
      procedure foo;
      ...
   B=class(A)
     procedure foo; override;
     ...
   C=class(B)
     procedure foo; override;
     ...
A(objC).foo();

그러나 Java에서는 일부 장비로만 이러한 초점을 맞출 수 있습니다. 한 가지 가능한 방법은 다음과 같습니다.

class A {               
   int y=10;            

   void foo(Class X) throws Exception {  
      if(X!=A.class)
         throw new Exception("Incorrect parameter of "+this.getClass().getName()+".foo("+X.getName()+")");
      y++;
      System.out.printf("A.foo(%s): y=%d\n",X.getName(),y);
   }
   void foo() throws Exception { 
      System.out.printf("A.foo()\n");
      this.foo(this.getClass()); 
   }
}

class B extends A {     
   int y=20;            

   @Override
   void foo(Class X) throws Exception { 
      if(X==B.class) { 
         y++; 
         System.out.printf("B.foo(%s): y=%d\n",X.getName(),y);
      } else { 
         System.out.printf("B.foo(%s) calls B.super.foo(%s)\n",X.getName(),X.getName());
         super.foo(X);
      } 
   }
}

class C extends B {     
   int y=30;            

   @Override
   void foo(Class X) throws Exception { 
      if(X==C.class) { 
         y++; 
         System.out.printf("C.foo(%s): y=%d\n",X.getName(),y);
      } else { 
         System.out.printf("C.foo(%s) calls C.super.foo(%s)\n",X.getName(),X.getName());
         super.foo(X);
      } 
   }

   void DoIt() {
      try {
         System.out.printf("DoIt: foo():\n");
         foo();         
         Show();

         System.out.printf("DoIt: foo(B):\n");
         foo(B.class);  
         Show();

         System.out.printf("DoIt: foo(A):\n");
         foo(A.class);  
         Show();
      } catch(Exception e) {
         //...
      }
   }

   void Show() {
      System.out.printf("Show: A.y=%d, B.y=%d, C.y=%d\n\n", ((A)this).y, ((B)this).y, ((C)this).y);
   }
} 

objC.DoIt () 결과 출력 :

DoIt: foo():
A.foo()
C.foo(C): y=31
Show: A.y=10, B.y=20, C.y=31

DoIt: foo(B):
C.foo(B) calls C.super.foo(B)
B.foo(B): y=21
Show: A.y=10, B.y=21, C.y=31

DoIt: foo(A):
C.foo(A) calls C.super.foo(A)
B.foo(A) calls B.super.foo(A)
A.foo(A): y=11
Show: A.y=11, B.y=21, C.y=31

간단하게 수행 할 수 있습니다. 예를 들어 :

B의 C 서브 클래스와 A의 B 서브 클래스. 둘 다 메소드 methodName ()이 있습니다.

public abstract class A {

    public void methodName() {
        System.out.println("Class A");
    }

}

public class B extends A {

    public void methodName() {
        super.methodName();
        System.out.println("Class B");
    }

    // Will call the super methodName
    public void hackSuper() {
        super.methodName();
    }

}

public class C extends B {

    public static void main(String[] args) {
        A a = new C();
        a.methodName();
    }

    @Override
    public void methodName() {
        /*super.methodName();*/
        hackSuper();
        System.out.println("Class C");
    }

}

클래스 C 실행 결과는 다음과 같습니다. 클래스 A 클래스 C

출력 대신 : 클래스 A 클래스 B 클래스 C

public class SubSubClass extends SubClass {

    @Override
    public void print() {
        super.superPrint();
    }

    public static void main(String[] args) {
        new SubSubClass().print();
    }
}

class SuperClass {

    public void print() {
        System.out.println("Printed in the GrandDad");
    }
}

class SubClass extends SuperClass {

    public void superPrint() {
        super.print();
    }
}

출력 : GrandDad에서 인쇄

키워드 super는 수퍼 클래스에서 메소드를 호출하는 방법입니다. Java 학습서에서 : https://docs.oracle.com/javase/tutorial/java/IandI/super.html

메소드가 수퍼 클래스의 메소드 중 하나를 대체하는 경우 키워드 super를 사용하여 대체 된 메소드를 호출 할 수 있습니다.

그것이 슈퍼 객체의 참조라고 믿지 마십시오! 아니요, 수퍼 클래스에서 메소드를 호출하는 키워드 일뿐입니다.

예를 들면 다음과 같습니다.

class Animal {
    public void doSth() {
        System.out.println(this);   // It's a Cat! Not an animal!
        System.out.println("Animal do sth.");
    }
}

class Cat extends Animal {
    public void doSth() {
        System.out.println(this);
        System.out.println("Cat do sth.");
        super.doSth();
    }
}

를 호출하면 클래스 cat.doSth()의 메소드 가 인쇄 되고 고양이입니다.doSth()Animalthis