超級調用父類方法

Question

比方說，我有三個類A，B和C

• B擴展一個
• ç延伸乙

所有定義一個public void foo()方法。

現在來自C的foo()方法我想調用A的foo()方法（不是它的父B的方法，而是超級超類A的方法）。

我試過super.super.foo();，但它的語法無效。 我該如何做到這一點？

Answer 1

你甚至不能使用反射。像

Class superSuperClass = this.getClass().getSuperclass().getSuperclass(); 
superSuperClass.getMethod("foo").invoke(this); 

東西會導致InvocationTargetException，因爲即使你呼籲superSuperClass foo的方法中，它仍然會使用C.foo()當您指定的調用「這個」。這是所有Java方法都是虛擬方法的結果。

看來你需要B類的幫助（例如定義一個superFoo(){ super.foo(); }方法）。

也就是說，如果您嘗試這樣的設計，看起來像是一個設計問題，所以給我們一些背景會有幫助：爲什麼您需要這樣做？

Answer 2

這是不可能的，我們僅限於調用超類的實現。

Answer 3

你不能 - 因爲它會破壞封裝。

你可以調用你的超類的方法，因爲它假定你知道什麼會破壞你自己的類中的封裝，並避免這種情況......但是你不知道你的超類執行什麼規則 - 所以你不能繞過這裏的實現。

Answer 4

你不能以簡單的方式做到這一點。

這是我認爲你可以這樣做：

有一個布爾在您的類B.現在，您必須調用B的由C foo的喜歡[super foo]但這樣做在此之前設定的布爾爲true。現在在B的foo中檢查bool是否爲真，然後不要執行任何步驟，只需調用A的foo。

希望這會有所幫助。

Answer 5

我smell東西很腥。

你確定你不只是推動信封太「只是因爲你應該能夠做到這一點」？你確定這是你可以得到的最好的設計模式嗎？你有沒有嘗試重構它？

Answer 6

我有一個問題，超類會調用被覆蓋的頂級方法。 這是我的解決方法...

//這會失敗致電超類方法爲A1（）將調用的頂級方法

class foo1{ 
public void a1(){ 
    a2(); 
    } 
public void a2(){} 
} 
class foo2 extends foo1{ 
{ 
public void a1(){ 
//some other stuff 
super.a1(); 
} 
public void a2(){ 
//some other stuff 
super.a2(); 
} 

//這保證了RIGHT SUPERCLASS方法被稱爲 //公有方法只調用私有方法，因此所有公共方法可以被覆蓋而不影響超類的功能。

class foo1{ 
public void a1(){ 
    a3();} 
public void a2(){ 
    a3();} 
private void a3(){ 
//super class routine 
} 
class foo2 extends foo1{ 
{ 
public void a1(){ 
//some other stuff 
super.a1(); 
} 
public void a2(){ 
//some other stuff 
super.a2(); 
} 

我希望這有助於。 :)

Answer 7

使用反射API之前，請考慮它的成本。

這很容易做到。例如：

B的B子類和B子類的A子類。三者都有方法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類

Answer 8

引述先前的回答：「你可以」 t - 因爲它會破壞封裝。「我想補充一點：

但是，有一個角落的情況下，你可以，即如果方法是static（public或protected）。你不能overwrite the static method。

有一個public static方法是微不足道的證明你確實可以做到這一點。

但對於protected，您需要從您的某個方法中對繼承路徑中的任何超類執行強制轉換，並調用該超類方法。

這是角落情況下，我在我的答案探索：

public class A { 
    static protected callMe(){ 
     System.out.println("A"); 
    } 
} 

public class B extends A { 
    static protected callMe(){ 
     System.out.println("B"); 
    } 
} 

public class C extends B { 
    static protected callMe(){ 
     System.out.println("C"); 
     C.callMe(); 
    } 

    public void accessMyParents(){ 
     A a = (A) this; 
     a.callMe(); //calling beyond super class 
    } 
} 

答案依然還是沒有，只是想表明的情況下就可以了，雖然它可能會沒有任何意義和只是一個練習。

Answer 9

是的，你可以做到這一點。這是一個黑客。儘量不要這樣設計你的程序。

class A 
{ 
    public void method() 
    { /* Code specific to A */ } 
} 

class B extends A 
{ 
    @Override 
    public void method() 
    { 
     //compares if the calling object is of type C, if yes push the call to the A's method. 
     if(this.getClass().getName().compareTo("C")==0) 
     { 
      super.method(); 
     } 
     else{ /*Code specific to B*/ } 

    } 
} 

class C extends B 
{ 
    @Override 
    public void method() 
    { 
     /* I want to use the code specific to A without using B */ 
     super.method(); 

    } 
}