# super() im Konstruktor



## seiden555 (19. Jan 2012)

Hallo,

ich bräuchte mal eure hilfe.... es geht um super()
normalerweise dient dieser doch dazu, um auf die oberklasse bei vererbung zu zugreifen oder?
in folgendem wird nicht mit vererbung gearbeitet. nur mit verketteten listen, falls das iwie relevant sein sollte.

ich hab in einer klasse jetzt 2 konstruktoren...
der erste konstruktor hat keine parameter und als inhalt nur ein "super()"
(mein verstand sagt mir super() geht nun in den konstruktor der oberklasse.. jedoch gibt es keine?)
der zweite konstruktor überlädt diesen dann und hat mehrere parameter die auf interne variablen im codeblock übergeben werden.

ich verstehe nicht wofür das super() an dieser stelle gut ist? 


wäre dankbar für eure hilfe


----------



## Gast2 (19. Jan 2012)

Das ist schon richtig.

```
super()
```
 ruft den parameterlosen Konstruktor der Oberklasse auf. Eine Oberklasse gibt es immer, wenn keine explizit angegeben ist, dann ist Object die Oberklasse.


----------



## Marco13 (19. Jan 2012)

Nenbebei: Ein einfaches, leeres 
super();
kann man auch weglassen...


----------



## HimBromBeere (19. Jan 2012)

... weil der Konstuktor der Oberklasse implizit sowieso immer aufegrufen wird.


----------



## Gast2 (19. Jan 2012)

Nicht ganz richtig HimBromBeere.
... weil der parameterlose Konstruktor, falls vorhanden, immer implizit aufgerufen wird.


----------



## HimBromBeere (19. Jan 2012)

> parameterlose Konstruktor


ist das nicht das selbe wie 
	
	
	
	





```
super();
```
?!


----------



## Schandro (19. Jan 2012)

... und wenn eine Klasse keine einzigen Konstruktor im Quellcode hat wird automatisch ein leerer parameterloser Konstruktor hinzugefügt.

@HimBromBeere
warum sollte der Aufruf des parameterlosen Konstruktors dasselbe sein wie ein parameterloser Konstruktor? oO Die Frage macht keinen Sinn.


----------



## HimBromBeere (19. Jan 2012)

Ich meine, mit super() wird ja genau dieser parameterlose Konstruktor aufgerufen... ich wollt ja nur nochmal erklären, warum man sich ein super() auch schenken kann...


----------



## Marco13 (19. Jan 2012)

Diese Diskussion ist wirklich super(); (d.h. die kann man sich schenken :joke: )


----------



## Schandro (19. Jan 2012)

Ich fas das jetzt noch mal für den TO zusammen:

1. Jeder Konstruktor muss als allerersten Aufruf einen Vaterkonstruktor aufrufen, außer wenn er mithilfe von this(..) einen anderen Konstruktor derselben Klasse aufruft. Falls der 
	
	
	
	





```
super(..);
```
 Aufruf fehlt fügt Java automatisch 
	
	
	
	





```
super();
```
 ein.

2. Jede Klasse muss mindestens einen Konstruktor besitzen, sollte dies nicht der Fall sein wird automatisch von Java ein parameterloser Konstruktor mit der Sichtbarkeit public ohne Inhalt erstellt (der automatisch 
	
	
	
	





```
super();
```
 aufruft, siehe Punkt 1)

3. Jede Klasse muss von einer anderen Klasse erben. Sollte kein extends angegeben sein, fügt Java automatisch ein 
	
	
	
	





```
extends Object
```
 ein.

PS: Punkt 3 gilt natürlich nicht für die Klasse Object...


----------



## hdi (20. Jan 2012)

Ich möchte Schandro's Post noch um einen Punkt ergänzen:



> 1. Jeder Konstruktor muss als allerersten Aufruf einen Vaterkonstruktor aufrufen, außer wenn er mithilfe von this(..) einen anderen Konstruktor derselben Klasse aufruft. Falls der super(..); Aufruf fehlt fügt Java automatisch super(); ein.



Richtig, _falls _die Vaterklasse einen parameterlosen Konstruktor bereitstellt. Ist dies nicht der Fall, kann weder Java automatisch ein implizites super() einfügen, noch wäre ein expliziter Aufruf von super() [beachte: leere Klammern!] korrekt. Die Kindklasse würde in diesem Fall nicht kompilieren, solange man nicht einen _expliziten _super-Aufruf im Konstruktor der Kindklasse verwendet, der den Vaterklassen-Konstruktor auch mit den erwarteten Werten bedient. 

Wenn man also ganz pingelig sein will, ist diese Aussage:


> Falls der super(..); Aufruf fehlt fügt Java automatisch super(); ein.


nicht korrekt, da ein super*(..)*, also ein Aufruf _mit Wertübergabe_, nicht das selbe ist wie ein super*()* Aufruf ohne Übergabe von Parameterwerten.

Wer jetzt verwirrt ist, ich meine folgendes:


```
class A{

   private Object data;
 
   // Durch Definition dieses Konstruktors gibt es keinen Default-Konstruktor in Klasse A mehr:
   public A(Object data){
      this.data = data;
   }
}
```


```
class B extends A{

    // Der Default-Konstruktor für B reicht hier nicht mehr aus, wir müssen ihn durch einen eigenen ersetzen:
    public B(){
        // super(); <- Kompiliert nicht, Konstruktor A() in Klasse A nicht vorhanden
        super(new Object()); // <- Wir müssen explizit den A(Object)-Konstruktor der Klasse A aufrufen
    }
}
```


----------



## Schandro (20. Jan 2012)

Diesen Sonderfall hatte ich extra ausgelassen weil er meinen Text umständlicher gemacht hätte, danke für den Nachtrag.


----------



## faetzminator (20. Jan 2012)

Wenn man einen Default-Konstruktor (natürlich nebst anderen Konstruktoren) implementiert, der wirklich nichts macht, würde ich auch zu [c]super();[/c] tendieren, da man sonst einen leeren Block hat. Natürlich könnte man als Alternative auch einen "schönen" Kommentar ala [c]// do nothing[/c] oder sonst einen Müll schreiben, aber der Entwickler sieht so oder so, dass der Konstruktor leer ist...


----------

