# überschriebene Methode von Vor-Vorfahren aufrufen



## kartoffelsack (29. Dez 2006)

Ich will die abgeleitete Klasse nicht die überschriebene Methode des direkten Vorfahrens sonder eine indirekten (quasi des Opas) aufrufen. Siehe Code.


```
class Foo
{
  public void doSomething()
  {
     System.out.println("doing something");
  }
}


class Bar extends Foo
{
  public void doSomething()
  {
     System.out.println("to idle to do something");
  }
}



class Foobar extends Bar
{
  public void doSomething()
  {
     super.doSomething() // ruft Bar.doSomething auf.
     // ich will aber Foo.doSomething aufrufen
     // Wie kann ich das machen???
  }
}
```


----------



## SlaterB (29. Dez 2006)

unmöglich und (wie immer wenn was in Java nicht geht  ) im normalen Betrieb auch nicht benötigt/ sinnvoll


----------



## Guest (29. Dez 2006)

In C++ passiert dies automatisch, wenn man falsch castet, alle fluchen und er will das freiwillig haben. :lol:


----------



## Leroy42 (29. Dez 2006)

Ich borge mir mal AlArenals Standardantwort zu derartigen Fragen.



			
				AlArenal hat gesagt.:
			
		

> _Wozu braucht man sowas!_



Ich kann mir beim besten Willen keine _vernünftige_ Problemstellung
vorstellen, bei der man in die Verlegenheit kommt, derartiges
zu benötigen.

Irgendwie widerspricht es auch dem _reinen_ OOD.


----------



## Beni (29. Dez 2006)

Auch wenn die Verwendung unklar ist; Die Frage ob und wie sowas möglich ist (oder wieso nicht?), finde ich interessant. Ich habe zuerst an Reflection gedacht, aber alles was ich gefunden habe, beachtet die Vererbung.


----------



## Guest (29. Dez 2006)

Wie wär's mit sowas, wenn wir schon bei Bad-Patterns sind. 

```
public class Test
{
   static class A
   {
      public void sayHello() {
         sayHello(this);
      }

      protected void sayHello(A a) {
         System.out.println("Hello from A");
      }
   }
   
   static class B extends A
   {
      public void sayHello() {
         sayHello(this);
      }

      protected void sayHello(B a) {
         System.out.println("Hello from B");
      }
   }
   
   static class C extends B
   {
      public void sayHello() {
         sayHello((A)this); // <-- Beachte den Cast
      }
   }
   
   public static void main(String[] args)
   {
      A a = new A();
      B b = new B();
      C c = new C();
      a.sayHello(); // A
      b.sayHello(); // B
      c.sayHello(); // A
   }

}
```


----------



## Guest (30. Dez 2006)

Hi!



			
				Anonymous hat gesagt.:
			
		

> Wie wär's mit sowas, wenn wir schon bei Bad-Patterns sind.
> [...]



Na und? Was hat das bitte mit der ursprünglichen Problemstellung zu tuen? Ich sag dir's: Gar nix! Die Methode "sayHello" der Klasse A ist eine ganz andere als die der Klasse B. Also wird in B nur eine zusätzliche Methode definiert, aber nicht die von A überschrieben, ergo sucht sich Java je nach Parameter eben eine von beiden aus!

Andy


----------

