# Aufruf von Konstruktor aus Basisklasse



## Alibi086 (8. Feb 2012)

Hallo zusammen!

Wie genau kann ich eigentlich bei drei Klassen (Klasse C extends Klasse B extends Klasse A) sicherstellen, dass die unterste Klasse C mittels super() Aufrufen den Konstruktor der Oberklasse A aufruft? Denn ein super.super() gibt es ja in Java nicht. Das wäre ja für mich interessant, wenn in Klasse A bspw. ein Attribut vorhanden ist, welches auch nur über den dort zugehörigen Konstruktor bei der Objekterzeugung befüllt werden kann?

Greetz
Felix


----------



## HimBromBeere (8. Feb 2012)

von C aus gar nicht, dann bräuchtest du in B auch ein super(). Aber implizit wird dieser Konstruktor sowieso aufgerufen (sofern es einen solchen gibt).


----------



## pro2 (8. Feb 2012)

Im Konstruktor von Klasse B super() aufrufen und dann in C einfach nur super() aufrufen?


----------



## Kevin94 (8. Feb 2012)

Das geht gar nicht, bzw. muss gar nicht, weil Java fest vorschreibt, dass die erste Aktion in einem Konstruktor immer der Aufruf eines Konstruktors der Vater-Klasse sein muss. (Wenn der Programmierer es nicht hinschreibt, dan fügt der Compiler heimli super(); ein, und wenn dieser Konstruktor nicht vorhanden ist, wird abgebrochen)
Daraus folgt für dein Problem, dass du in der Vater-Klasse einen Konstruktor schreiben musst, der die nötigen werte an die Großvater-Klasse weitergibt.


----------



## Tomate_Salat (8. Feb 2012)

Google, Fachliteratur?! Das sind Grundlagen. Notfalls kann man soetwas mit einem Test ausprobieren, ob der expliziete super-aufruf überhaupt notwendig ist:


```
public class A 
{
	public A() {
		System.out.println("Ich bin der Konstruktor von A!");
	}
	
	public static void main(final String[] args) {
		new C();
	}
}

class B extends A
{
	public B() {
		System.out.println("Ich bin der Konstruktor von B!");
	}
}

class C extends B
{
	public C() {
		System.out.println("Ich bin der Konstruktor von C!");
	}
}
```

An dem Ergebnis siehst du auch die Reihenfolge, welcher Konstruktor zuerst und welcher zuletzt aufgerufen wird.

Btw: hat eine Klasse keinen default-konstruktor, dann musst du explizit den Konstruktor der super-klasse aufrufen:

```
class D
{
	public D(final Object any) {
		System.out.println("Ich bin der Konstruktor von D mit Parameter!");
	}
}

class E extends D
{
	public E() {
		super(null);
	}
}
```

ansonsten bekommst du ein:


```
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Implicit super constructor D() is undefined for default constructor. Must define an explicit constructor

	at E.<init>(A.java:35)
	at A.main(A.java:10)
```

----------------

[WR]
DennisXX, zeig mal bitte ein wenig mehr Eigeninitiative, sonst vergeht den Leuten irgendwann die Lust dir zu helfen. Dann ist es auch nicht notwendig hier multiaccounts zu verwenden. 
[/WR]


----------



## Blinda (8. Feb 2012)

Hey Ho Tomate_Salat...kannst du die Rückgabe deines kleinen Bsp kurz aufschreiben....sitz hier grad mit nem Handy und es würd mich interessieren...danke


----------



## HimBromBeere (8. Feb 2012)

> die Rückgabe deines kleinen Bsp


Beantwortet dies die Frage?


> die erste Aktion in einem Konstruktor immer der Aufruf eines Konstruktors der Vater-Klasse sein muss.



Rate, was dann im Endeffekt rauskommt...


----------



## Tomate_Salat (8. Feb 2012)

```
Ich bin der Konstruktor von A!
Ich bin der Konstruktor von B!
Ich bin der Konstruktor von C!
```

Das kann man sich auch logisch herleiten. Das erste was in einem von dir geschrieben Konstruktor passiert, ist der Aufruf super. Auch wenn man diesen nicht explizit hinschreibt. Da super() den Konstruktor des Parent-Objektes aufruft, muss also erst die oberste Klasse seine Arbeit verrichten, bevor die anderen Dran sind. Also gilt für uns:


```
Aufruf des Konstruktors von: java.lang.Object
Aufruf des Konstruktors von: A
Aufruf des Konstruktors von: B
Aufruf des Konstruktors von: C
```


----------

