为什么是 super.super.method(); Java中不允许？

Question

我读了

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

我不确定它在很多情况下是否有用，但我想知道为什么 事实并非如此，如果其他语言中也存在类似的情况。

你们有什么感想？

编辑： 澄清一下：是的，我知道，这在 Java 中是不可能的，而且我并不真正怀念它。 这不是我期望的工作，并且很惊讶收到编译器错误。 我只是有这个想法并想讨论它。

Answer 1

我认为以下代码允许在大多数情况下使用 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);
    }
}

Answer 2

我没有足够的声誉来发表评论，因此我会将其添加到其他答案中。

乔恩·斯基特（Jon Skeet）的回答非常出色，并举了一个很好的例子。 Matt B 有一个观点：并非所有超类都有超类。 如果您调用没有超级的超级的超级，您的代码将会崩溃。

面向对象编程（Java 就是这样）是关于对象的，而不是函数。 如果您想要面向任务的编程，请选择 C++ 或其他语言。 如果你的对象不适合它的超类，那么你需要将它添加到“祖父母类”，创建一个新类，或者找到另一个它适合的超类。

就我个人而言，我发现这个限制是 Java 最大的优势之一。 与我使用过的其他语言相比，代码有些僵化，但我总是知道会发生什么。 这有助于实现 Java 的“简单且熟悉”的目标。 在我看来，调用 super.super 并不简单也不熟悉。 或许开发商也有同感？

Answer 3

这样做有一些充分的理由。 您可能有一个子类，该子类的方法实现不正确，但父类方法实现正确。 因为它属于第三方库，所以您可能无法/不愿意更改源。 在这种情况下，您想要创建一个子类，但重写一个方法来调用 super.super 方法。

正如其他一些海报所示，可以通过反射来做到这一点，但应该可以做类似

(SuperSuperClass this).theMethod(); 的

事情。 我现在正在处理这个问题 - 快速解决方法是将超类方法复制并粘贴到子子类方法中:)

Answer 4

除了其他人提出的非常好的观点之外，我认为还有另一个原因：如果超类没有超类怎么办？

由于每个类自然地扩展（至少）Object，因此 super.whatever() 将始终引用超类中的方法。 但是，如果您的类仅扩展 Object 呢？那么 super.super 会指代什么呢？ 应该如何处理该行为 - 编译器错误、空指针等？

我认为不允许这样做的主要原因是它违反了封装，但这也可能是一个小原因。

Answer 5

我认为，如果您覆盖一个方法并想要它的所有超类版本（例如 equals），那么您实际上总是希望首先调用直接超类版本，哪个版本将调用如果需要的话，依次调用其超类版本。

我认为调用某个方法的任意超类版本几乎没有意义（如果有的话。我想不出它的情况）。 我不知道这在 Java 中是否可行。 可以用 C++ 完成：

this->ReallyTheBase::foo();

Answer 6

猜测是因为它不经常使用。 我看到使用它的唯一原因是如果您的直接父母覆盖了某些功能并且您试图将其恢复为原始状态。

在我看来，这违反了面向对象的原则，因为类的直接父类应该比祖父母与你的类的关系更密切。

Answer 7

当您无法更改基类的代码时，调用 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 中的真实类之前加载。 然后重写方法或构造函数。

注意：这绝对是黑客行为，强烈不建议使用，但它确实有效！ 使用这种方法是危险的，因为类加载器可能会出现问题。 此外，每次更新包含被覆盖类的库时，这都可能会导致问题。

Answer 8

@Jon Skeet 很好的解释。
在我看来，如果有人想要调用 super.super 方法，那么一定是想要忽略直接父级的行为，但想要访问祖父级的行为。
这可以通过实例化来实现。 如下代码所示

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

Answer 9

查看 这个 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";
        }
    }
}

快乐编码！！！！

Answer 10

如果可能的话，我会将 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();

结果都是“我是超级超级”

Answer 11

使用反射至少可以获得超类的超类的类，尽管不一定是它的实例； 如果这可能有用，请考虑 http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass()

Answer 12

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

     }
}

跑步：
A
构建成功（总时间：0 秒）

Answer 13

当架构要在代表多个派生类实现的通用 CustomBaseClass 中构建通用功能时，我遇到过类似的情况。
但是，我们需要规避特定派生类的特定方法的通用逻辑。 在这种情况下，我们必须使用 super.super.methodX 实现。

我们通过在 CustomBaseClass 中引入一个布尔成员来实现这一点，该成员可用于有选择地推迟自定义实现并在需要时屈服于默认框架实现。

        ...
        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分钱...

Answer 14

IMO，这是在 Java 中实现 super.super.sayYourName() 行为的一种简洁方法。

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

输出：

请求撒谎：d.sayYourName(true) 返回 Grandma Fedora
请求不要说谎：d.sayYourName(false) 返回小女孩玛莎

Answer 15

我认为这是一个破坏继承协议的问题。
通过扩展一个类，您遵守/同意其行为、功能
当调用 super.super.method() 时，您想打破自己的服从协议。

您不能从超类中挑选。

然而，可能会出现这样的情况：您觉得需要调用 super.super.method() - 通常是一个糟糕的设计标志，在您的代码或您继承的代码中！
如果super和super super类无法重构（一些遗留代码），那么选择组合而不是继承。

封装破坏是指通过破坏封装的代码来@Override某些方法。
设计为不被覆盖的方法被标记
最终。

Answer 16

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

您也可以在 Delphi 中执行此操作：

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

Answer 17

这很容易做到。 例如：

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级

Answer 18

如果您认为需要超类，则可以在该类的变量中引用它。 例如：

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

Answer 19

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 中

Answer 20

关键字 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() 时，Animal 类中的方法 doSth() 将打印 this< /code> 它是一只猫。

Answer 21

它违反了封装性。 您不应该能够绕过父类的行为。 有时能够绕过您自己的类的行为（特别是在同一方法中）而不是您父类的行为是有意义的。 例如，假设我们有一个基础“项目集合”，一个代表“红色项目集合”的子类以及代表“大红色项目集合”的子类。 这是有道理的：

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中的不变量被破坏了。

那有意义吗？

Answer 22

我认为乔恩·斯基特有正确的答案。 我想补充一点，您可以通过转换 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）

但是，这不起作用对于方法调用，因为方法调用是根据对象的运行时类型确定的。