[java] Java가 정적 메소드 대체를 허용하지 않는 이유는 무엇입니까?

짧은 대답은 : 그것은 가능하지만 Java는 그렇지 않습니다.

다음은 Java 의 현재 상태 를 보여주는 코드입니다 .

파일 Base.java:

package sp.trial;
public class Base {
  static void printValue() {
    System.out.println("  Called static Base method.");
  }
  void nonStatPrintValue() {
    System.out.println("  Called non-static Base method.");
  }
  void nonLocalIndirectStatMethod() {
    System.out.println("  Non-static calls overridden(?) static:");
    System.out.print("  ");
    this.printValue();
  }
}

파일 Child.java:

package sp.trial;
public class Child extends Base {
  static void printValue() {
    System.out.println("  Called static Child method.");
  }
  void nonStatPrintValue() {
    System.out.println("  Called non-static Child method.");
  }
  void localIndirectStatMethod() {
    System.out.println("  Non-static calls own static:");
    System.out.print("  ");
    printValue();
  }
  public static void main(String[] args) {
    System.out.println("Object: static type Base; runtime type Child:");
    Base base = new Child();
    base.printValue();
    base.nonStatPrintValue();
    System.out.println("Object: static type Child; runtime type Child:");
    Child child = new Child();
    child.printValue();
    child.nonStatPrintValue();
    System.out.println("Class: Child static call:");
    Child.printValue();
    System.out.println("Class: Base static call:");
    Base.printValue();
    System.out.println("Object: static/runtime type Child -- call static from non-static method of Child:");
    child.localIndirectStatMethod();
    System.out.println("Object: static/runtime type Child -- call static from non-static method of Base:");
    child.nonLocalIndirectStatMethod();
  }
}

이것을 실행하면 (Java 1.6을 사용하여 Eclipse에서 Mac에서 수행) 다음을 얻습니다.

Object: static type Base; runtime type Child.
  Called static Base method.
  Called non-static Child method.
Object: static type Child; runtime type Child.
  Called static Child method.
  Called non-static Child method.
Class: Child static call.
  Called static Child method.
Class: Base static call.
  Called static Base method.
Object: static/runtime type Child -- call static from non-static method of Child.
  Non-static calls own static.
    Called static Child method.
Object: static/runtime type Child -- call static from non-static method of Base.
  Non-static calls overridden(?) static.
    Called static Base method.

여기에서 유일한 놀람이 될 수 있습니다 (그리고 어떤 질문에 대한됩니다) 표시의 경우는 수하는 첫 번째 사례 :

“런타임 유형은 객체 인스턴스 ( obj.staticMethod())를 사용하여 호출 할 때 호출되는 정적 메소드를 결정하는 데 사용되지 않습니다 .”

그리고 마지막 경우 :

“클래스의 객체 메소드 내에서 정적 메소드를 호출 할 때 선택한 정적 메소드 는 객체의 런타임 유형을 정의하는 클래스가 아니라 클래스 자체에서 액세스 할 수 있는 메소드입니다.”

객체 인스턴스로 호출

정적 호출은 컴파일 타임에 해결되지만 비 정적 메소드 호출은 런타임에 해결됩니다. 정적 메소드는 (부모로부터) 상속 되지만 (자식에 의해) 재정의 되지는 않습니다 . 당신이 달리 예상했다면 이것은 놀랍습니다.

객체 메소드 내에서 호출

객체 메소드 호출은 런타임 유형을 사용하여 해결되지만 정적 ( class ) 메소드 호출은 컴파일 시간 (선언) 유형을 사용하여 해결됩니다.

규칙 변경

이러한 규칙을 변경하여라는 예제의 마지막 호출에서 Child.printValue()컴파일러가 선언 된 객체 클래스로 컴파일 타임에 호출을 해결하는 대신 런타임에 정적 호출에 유형을 제공해야합니다. 문맥). 정적 호출은 오늘날 객체 메소드 호출과 마찬가지로 (동적) 유형 계층 구조를 사용하여 호출을 해결할 수 있습니다.

이것은 쉽게 할 수 있으며 (Java를 변경 한 경우 : -O) 전혀 부당한 것은 아니지만 몇 가지 흥미로운 고려 사항이 있습니다.

주요 고려 사항은 어떤 정적 메서드 호출을 수행 해야하는지 결정 해야한다는 것입니다.

현재 Java에는 obj.staticMethod()호출이 호출로 대체되는 언어 ObjectClass.staticMethod()(일반적으로 경고가 표시됨) 에이 “질투”가 있습니다 . [ 참고 : ObjectClass 의 컴파일 타임 유형입니다 obj.] 런타임 유형 의을 사용하여 이러한 방식으로 재정의 할 수 있습니다 obj.

그렇게하면 메소드 본문을 읽기가 더 어려워 질 것이다. 부모 클래스의 정적 호출은 동적으로 “재 라우팅” 될 수있다 . 이를 피하려면 클래스 이름으로 정적 메소드를 호출해야합니다. 이렇게하면 컴파일 타임 유형 계층 구조 (지금과 같이)로 호출이보다 명확하게 해결됩니다.

정적 메소드를 호출하는 다른 방법은 더 까다 롭습니다. 의 런타임 유형을 사용 this.staticMethod()하는 것과 같은 의미 여야합니다 . 그러나 이로 인해 기존 프로그램에서 두통이 발생할 수 있습니다 .obj.staticMethod()thisthis.method()

그래서 무의미한 통화는 staticMethod()어떻습니까? 나는 그들이 오늘날과 똑같이하고 지역 수업 맥락을 사용하여 무엇을 해야할지 결정하는 것이 좋습니다. 그렇지 않으면 큰 혼란이 생길 ​​것입니다. 물론 그것은 그것이 의미하는 method()것을 의미 this.method()하는 경우 method가 아닌 정적 메서드, 그리고 ThisClass.method()경우는 method정적 방법이었다. 이것은 또 다른 혼란의 근원입니다.

다른 고려 사항

우리가이 동작을 변경 (정적 호출 가능성이 동적으로 로컬이 아닌했다), 우리는 아마의 의미를 다시 방문 할 것 final, private그리고 protected예선과 (와) 같은 static클래스의 방법. 우리는 모두 메소드 private static와 public final메소드가 재정의되지 않았으므로 컴파일 타임에 안전하게 해결 될 수 있으며 로컬 참조로 읽을 수 있도록 “안전” 하다는 사실에 익숙해 져야합니다.

답변

import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;

class RegularEmployee {

    private BigDecimal salary = BigDecimal.ONE;

    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }
    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".02");
    }
    public BigDecimal calculateBonus() {
        return salary.multiply(this.getBonusMultiplier());
    }
    public BigDecimal calculateOverridenBonus() {
        try {
            // System.out.println(this.getClass().getDeclaredMethod(
            // "getBonusMultiplier").toString());
            try {
                return salary.multiply((BigDecimal) this.getClass()
                    .getDeclaredMethod("getBonusMultiplier").invoke(this));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
    // ... presumably lots of other code ...
}

final class SpecialEmployee extends RegularEmployee {

    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".03");
    }
}

public class StaticTestCoolMain {

    static public void main(String[] args) {
        RegularEmployee Alan = new RegularEmployee();
        System.out.println(Alan.calculateBonus());
        System.out.println(Alan.calculateOverridenBonus());
        SpecialEmployee Bob = new SpecialEmployee();
        System.out.println(Bob.calculateBonus());
        System.out.println(Bob.calculateOverridenBonus());
    }
}

0.02
0.02
0.02
0.03

RegularEmployee Carl = new SpecialEmployee();

System.out.println(Carl.calculateBonus());
System.out.println(Carl.calculateOverridenBonus());

0.02
0.03

class MyClass { ... }
class MySubClass extends MyClass { ... }

MyClass obj1 = new MyClass();
MySubClass obj2 = new MySubClass();

ob2 instanceof MyClass --> true

Class clazz1 = obj1.getClass();
Class clazz2 = obj2.getClass();

clazz2 instanceof clazz1 --> false

Animal lassie = new Dog();
lassie.speak(); // outputs "woof!"
Animal kermit = new Frog();
kermit.speak(); // outputs "ribbit!"

class Animal {
    public static void eat() {
        System.out.println("Animal Eating");
    }
}

class Dog extends Animal{
    public static void eat() {
        System.out.println("Dog Eating");
    }
}

class Test {
    public static void main(String args[]) {
       Animal obj= new Dog();//Dog object in animal
       obj.eat(); //should call dog's eat but it didn't
    }
}


Output Animal Eating