überschriebene Methode in Konstruktor der Unterklasse

MamboKurt

also ich hab da eine frage:
ich habe eine oberklasse und eine unterklasse. in beiden habe ich einen bestimmten konstruktor, der die selben paramenter bekommt. dieser konstruktor greift auf eine methode zurück, die ich in der unterklasse überschrieben habe.

Bsp.:

// Oberklasse -----------------------

class Oberklasse
{
   public Oberklasse() {}

   public Oberklasse(int foo, int bar)
   {
      foomethode(foo,bar);
   }

   public void foomethode(int foo, int bar)
   {
      this.x = foo;
      this.y = bar;
   }

   protected int x;
   protected int y;
}

// Unterklasse ------------------------

class Unterklasse extends Oberklasse
{
   public Unterklasse() {}

   public Unterklasse(int foo, int bar)
   {
      super(foo,bar);
   }

   public void foomethode(int foo, int bar) // hier überschrieben
   {
      this.x = foo/2; // ist hier eine andere Methode
      this.y = bar/2; // als in der Oberklasse
   }
}

wenn ich im konstruktor Unterklasse(int foo, int bar) der Konstruktor super(foo, bar) von Oberklasse(int foo, int bar) aufrufe, ruft dieser die methode foomethode von Oberklasse oder von Unterklasse auf?
Würde es unter normal umständen ausprobieren, ist aber nicht möglich im mom.
also danke schon mal für eure antoworten.

.MamboKurt

Wenn du

new Unterklasse(1, 2);

Machst wird auch vom Oberklasse konstruktor die überschriebene foomethode aufgerufen.

Wenn ich es nochmal les klingts voll misverständlich.

Die:

public void foomethode(int foo, int bar) // hier überschrieben
   {
      this.x = foo/2; // ist hier eine andere Methode
      this.y = bar/2; // als in der Oberklasse
   }

wird aufgerufen.

Müsste das jetzt die überschreibende Methode heißen?

MamboKurt

danke für die antwort.

Müsste das jetzt die überschreibende Methode heißen?

mit aktiv und passiv hatte ich es noch nie so

Javaner

Müsste das jetzt die überschreibende Methode heißen?

Nein! Das würde ja bedeuten, daß es eine Methode gibt,
die eine (andere) überschreibt.

In z.B. Lisp könntest du tatsächlich eine Methode
definieren die, bei Aufruf, eine bereits existierende
Methode überschreibt; in den meisten anderen Sprachen
geht das nicht.