爲何是super.super.method（）; Java中不容許？

我讀了這個問題，並認爲若是能夠寫的話，很容易解決（不是沒有它就不能解決）： html

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

我不肯定在不少狀況下它是否有用，可是我想知道爲何它沒有用，以及其餘語言中是否存在相似的東西。 java

大家有什麼感想？ api

編輯：澄清一下：是的，我知道，這在Java中是不可能的，我也不是很想念它。 這不是我指望的工做，而且驚訝於出現編譯器錯誤。 我只有這個主意，喜歡討論。 架構

#1樓

彷佛至少可使用反射來獲取超類的超類的類，儘管不必定是它的實例。 若是這可能有用，請考慮Javadoc，網址爲http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass（） 框架

#2樓

當架構是在表明幾個派生類實現的通用CustomBaseClass中構建通用功能時，我曾遇到過相似狀況。 可是，咱們須要針對特定​​派生類的特定方法規避通用邏輯。 在這種狀況下，咱們必須使用super.super.methodX實現。 ide

咱們經過在CustomBaseClass中引入一個布爾成員來實現此目的，該布爾成員可用於有選擇地推遲自定義實現並在須要時屈服於默認框架實現。 this

...
        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(...);
                       }
        }

可是，在框架和應用程序中遵循良好的架構原則，經過使用hasA方法而不是isA方法，咱們能夠輕鬆避免此類狀況。 可是在任什麼時候候，指望設計良好的體系結構都不太可行，所以須要擺脫紮實的設計原則並引入相似的技巧。 只是個人2美分... spa

#3樓

@Jon Skeet很好的解釋。 IMO若是有人要調用super.super方法，則必需要忽略直接父級的行爲，但要訪問大父級的行爲。 這能夠經過實例Of來實現。 以下代碼 .net

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的理想或良好作法，但仍然有效。

#4樓

若是可能的話，我會把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();
    }
}

或者，若是您不能更改super-super類，則能夠嘗試如下操做：

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();

結果爲「我是超級超級」

#5樓

我認爲這是一個破壞繼承協議的問題。
經過擴展課程，您能夠遵照/贊成其行爲，功能
在調用super.super.method() ，您想打破本身的服從協議。

你不能從超級班上挑櫻桃 。

可是，在某些狀況下，您可能須要在代碼中或在您繼承的代碼中調用super.super.method() -一般是一個錯誤的設計標誌！
若是超級 超級超級類不能被重構（一些舊的代碼），而後選擇超過繼承組成。

封裝破壞是當您經過破壞封裝的代碼@Override一些方法時。 設計爲不可覆蓋的方法標記爲final 。