Un appel à super super méthode de classe

Vous ne pouvez même pas utiliser la réflexion. Quelque chose comme

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

conduirait à une InvocationTargetException, parce que même si vous appelez le foo-Méthode sur la superSuperClass, on utilise toujours C.foo() lorsque vous spécifiez "ce" en invoquer. C'est une conséquence du fait que toutes les méthodes de Java sont des méthodes virtuelles.

Il semble que vous besoin de l'aide de la classe B (par exemple en définissant un superFoo(){ super.foo(); } méthode).

Cela dit, ça ressemble à un problème de conception si vous essayez quelque chose comme ça, alors il serait utile de nous donner un peu de contexte: Pourquoi vous besoin de faire cela?

Vous ne pouvez pas le faire d'une manière simple.

C'est ce que je pense que vous pouvez faire:

Ont un bool dans votre classe B. Maintenant, vous devez appeler B foo de C comme [super foo] mais avant de le faire ensemble le booléen à true. Maintenant en B foo vérifier si le booléen est vrai, alors ne pas exécuter toutes les étapes et il suffit d'appeler Un des foo.

Espère que cette aide.

Oui vous pouvez le faire. C'est un hack. Essayez de ne pas la conception de votre programme de ce genre.

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

    }
}

Je l'odeur quelque chose de louche ici.

Êtes-vous sûr que vous ne sont pas seulement de repousser les limites trop loin "juste parce que vous devriez être en mesure de le faire"? Êtes-vous sûr que c'est le meilleur modèle de conception que vous pouvez obtenir? Avez-vous essayé la refactorisation?

Avant l'utilisation de la réflexion de l'API de réfléchir sur le coût de celui-ci.

Il est tout simplement facile à faire. Par exemple:

C sous-classe de B et B sous-classe de A. Deux des trois méthodes methodName() par exemple.

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

}

Exécuter classe C Sortie sera:
De Classe A
Classe C

Au lieu de la sortie:
De Classe A
Classe B
Classe C

Il y a une solution qui a résolu mon problème similaire:

À l'aide de la classe A, B, et C scénario, il y a une méthode qui ne sera pas briser l'encapsulation et ne demande de déclarer la classe C à l'intérieur de la classe B. La solution de contournement consiste à déplacer de la classe B les méthodes de la dans un mais la méthode protégée.

Puis, si ceux de la classe B les méthodes ne sont pas tenus simplement remplacer cette méthode, mais n'utilisez pas "super" à l'intérieur de cette méthode. Primordial de ne rien faire et neutralise efficacement que la classe B de la méthode.

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

public class B extends A {
    protected void callMe() {
        super.callMe();
        methodsForB(); //Class B methods moved out and into it's own method
    }

    protected void methodsForB() {
        System.out.println("methods for B");
    }
}

public class C extends B {

    public static void main(String[] args) {
        new C().callMe();
    }

    protected void callMe() {
        super.callMe();
        System.out.println("callMe for C");
    }

    protected void methodsForB() {
        //Do nothing thereby neutralising class B methods 
    }
}

Le résultat sera:

callMe for A
callMe for C