Konstruktoren -> Funktionsaufrufe

[Vintner]

Hallo,

ich verstehe leider nicht ganz wie Funktionsaufrufe in Superkonstruktoren ablaufen.
Am besten gebe ich ein kleines Beispiel:

public class A{

   protected int x = 1;

   public A(){
      setX();
   }

   protected setX(){
      x = 2;
   }
}//class A


public class B extends A{

   private B(){ //.....

   public setX(){
      x = 3;

   public static B make(){ 
      return new B();
   }
}//class B

Beim Erstellen eines Objektes von B wird im B-Konstruktor nach Erstellen eines kompletten B-Objekts im Speicher und Initialisierung aller Objektvariablen der Super-Konstruktor (A-Konstruktor) aufgerufen.
(java.lang.object mal ausgelassen)
Wie wird im Elternkonstruktor nun auf Methoden zugegriffen?
Wird geschaut, ob in der Elternklasse die Funktion mit Zugriffsrechten von B aus vorhanden ist?
Und wenn nicht wird geschaut, ob auf die Funktion in der nächsten Kindklasse zuzugreifen ist, bis man in der letzten Kindklasse angekommen ist? Da auf diese ja stets zuzugreifen ist.

Erben mehr als 2 Klassen von einander blicke ich da leider nicht mehr ganz durch wenn ich das programmiertechnisch teste.

Kennt jemand vielleicht eine allgemeine Reihenfolge und Sichtweise wie auf Funktionen in Konstruktoren zugegriffen wird, inkl. Geheimnisprinzip?


Viele Grüße

 

[Volvagia]

Es werden von der Eltern- i. d. R. niemals die Methoden der Kindklassen benutzt, nur umgekehrt. Das wäre eventuell möglich, wenn du this castest und dann darauf zugreift, aber soetwas sollte immer nur in eine Richtung funktionieren. Sonst hast du ja ein kuddelmuddel wo theoretisch Zyklen entstehen können.

 

[Vintner]

Bei folgenden zwei Beispielen gibt es halt 2 unterschiedliche Methoden die aufgerufen werden.
Ich weiß da nicht genau wie da die Regeln der Konstruktoren sind:

1:

public class X{
	public int x = 1;
	protected X(){
		f();
	}
	private void f(){
		x=2;
	}
}

public class Y extends X{
		public void f(){
		x=3;
	}
	private Y(){
		super();
	}
	public static Y make(){
		return new Y();
	}
}

public class demo {
	public static void main(String[] args){
		System.out.println("y.x = " + Y.make().x);
		//System.out.println("y.v = " + Y.make().v);
	}
}

-> x = 2

2: ( Die Methode f() wird nur auf protected gesetzt, sonst alles gleich)

public class X{
	public int x = 1;
	protected X(){
		f();
	}
	protected void f(){
		x=2;
	}
}

public class Y extends X{
		public void f(){
		x=3;
	}
	private Y(){
		super();
	}
	public static Y make(){
		return new Y();
	}
}

public class demo {
	public static void main(String[] args){
		System.out.println("y.x = " + Y.make().x);
		//System.out.println("y.v = " + Y.make().v);
	}
}

-> x = 3

Hier wird einmal die Methode der Elternklasse benutzt und einmal der Kindklasse ...

 

[Volvagia]

Ich erkenne da absolut keinen Unterschied. ???:L
Aber zuerst wird der Superkonstruktor aufgerufen, das muss in jeden Konstruktor (Object mal ausgenommen) so sein.

 

[Vintner]

Jetzt bin ich wieder durcheinander gekommen, sry.

Also im Beispiel wird im Konstruktor der Elternklasse f() aufgerufen.

Ist f() in der Elternklasse private und in der Kindklasse public überschrieben wird die Funktion der Elternklasse ausgeführt.
Ist f() in der Elternklasse protected oder public wird die Kind-Funktion ausgeführt.

Beispiel oben korrigiert:
(Funktion der Kind-Klasse: x=3)

public class X{
	public int x = 1;
	protected X(){
		f();
	}
	public void f(){               // hier f() noch public
		x=2;
	}
}//X
public class Y extends X{
	public void f(){
		x=3;
	}
	private Y(){
		super();
	}
	public static Y make(){
		return new Y();
	}
}//Y

(Funktion der Elternklasse)

public class X{
	public int x = 1;
	protected X(){
		f();
	}
	private void f(){         // und hier auf private gesetzt.
		x=2;
	}
}

 

[Volvagia]

Ach so, klar.
Private Methoden werden nicht vererbt, dadurch überschreibst du in der Kind nicht die Methode sondern legst eine vollkommen neue an.

 

[Vintner]

Dann wird also von der Kindklasse aus gesehen die f()-Methode aufgerufen.
Wird diese überschrieben kommt die Kind-Klasse zum tragen, andernfalls die der Elternklasse.
-> Immer alles aus Sicht der Kindklasse sehen

 

[Volvagia]

Genau, wenn du in der Kindklasse etwas überschreibst wird von der Superklasse die neue implementation aufgerufen. Deshalb darf man niemals willkürlich Methoden überschreiben.