# Konstruktoren in Java



## SilencerandLois (24. Jan 2012)

Hallo,
hier mal eine Glaubensfrage zu überladenen Konstruktoren. Welche der drei Konsturktoren würdet ihr warum bevorzugen?


```
private Integer mX;
private Integer mY; 

public Foo (Integer pX) {
  mX = pX;
}

public Foo (Integer pX, Integer pY) {
   mX = pX;
   mY = pY;
}
```



```
private Integer mX;
private Integer mY; 

public Foo (Integer pX) {
  mX = pX;
}

public Foo (Integer pX, Integer pY) {
   this(pX);
   mY = pY;
}
```


```
private Integer mX;
private Integer mY; 

public Foo (Integer pX) {
   this (pX, null);
}

public Foo (Integer pX, Integer pY) {
   mX = pX;
   mY = pY;
}
```

Jetzt bin ich wirklich auf eure Antworten gespannt :toll:

Viele Grüße,
Martin


----------



## Final_Striker (24. Jan 2012)

SilencerandLois hat gesagt.:


> hier mal eine Glaubensfrage zu überladenen Konstruktoren. Welche der drei Konsturktoren würdet ihr warum bevorzugen?



Ich bevorzuge die erste Art. Das liegt aber daran, dass ich mir solche Konstruktoren von Eclipse generieren lasse und diese halt wie im ersten Beispiel aussehen.


----------



## Antoras (24. Jan 2012)

Ich würde die dritte Art bevorzugen. Da gibt es nur einen Hauptkonstruktor, der für die Initialisierung des Objekts zuständig ist. Die anderen rufen diesen dann mit gegebenenfalls manipulierten Werten auf. Das macht das ganze übersichtlich und wartbarer.

Anstatt null würde ich gegebenenfalls eher einen anderen Default-Value benutzen. Bei Integer von mir aus 0, -1 oder Integer.MAX_VALUE.


----------



## irgendjemand (24. Jan 2012)

ich würde nicht unbedingt [c]this[/c] verwenden um einen konstruktor zu überladen sondern diese dann auch auschreiben und returnen ... ansonsten bekommst du vom compiler die warnung das mit [c]this[/c] an einem objekt rumspielst was noch nicht völlig initialisiert ist *wesshalb man innerhalb eines konstruktors auch kein [c]this[/c] verwenden sollte*


----------



## HimBromBeere (24. Jan 2012)

> vom compiler die warnung das mit this an einem objekt rumspielst was noch nicht völlig initialisiert ist *wesshalb man innerhalb eines konstruktors auch kein this verwenden sollte*


Hab ich noch nie gehört und so eine Warnung hab ich auch noch nie gesehen... abgesehen davon ist, wenn man HDI glauben darf, "this" so ziemlich das Erste, was beim Instanziieren fertig gebaut ist... (schicke gleich noch den Link zu dem Beitrag, auf den ich mich hier beziehe). 
Das Weiterleiten von Konstruktoren ist überdies eine doch recht ziemlich elegante Variante (ob nun über den Klassennamen selbst oder this spielt dabei aber keine Rolle).

EDIT: so, hier ist der Beitrag, den ich meine: http://www.java-forum.org/java-basics-anfaenger-themen/130066-konstruktor-konstruktor.html#post850066

EDIT: Ich finde überdies alle drei Varianten ziemlich bescheiden. Ich nehme mal an, dass pX und pY sollen Koordinaten von irgendewas sein, also gleichberechtigt. Warum sollte man dann also eine Instanz mit x- aber ohne y-Koordinate erzeugen dürfen (anderherum jedoch nicht). 
Müsste ich mich entscheiden zwischen Cholera, Pest und SARS würde ich wahrscheinlich für *Variante III stimmen, da hiermit doppelter Code so weit wie möglich vermieden wird *(stell dir mal vor, du müsstest noch mehr Instanzvariablen initialisieren, dann würden da ziemlich viele identische Zeilen mehfrach vorkommen). Machst du die Weiterleitung über this(...) hast du nur diese eine Zeile in ALLEN Konstruktoren.


----------



## Michael... (24. Jan 2012)

Für mich ist Variante 3 die einzig ware ;-) wobei ich abhängig von Sinn und Zweck "offene" Attribute nicht mit null sondern mit einem Defaultwert initialisieren würde.


----------



## moonermo (24. Jan 2012)

Michael... hat gesagt.:


> Für mich ist Variante 3 die einzig ware ;-) wobei ich abhängig von Sinn und Zweck "offene" Attribute nicht mit null sondern mit einem Defaultwert initialisieren würde.



Dem schließe ich mich voll und ganz an


----------



## bygones (24. Jan 2012)

Michael... hat gesagt.:


> Für mich ist Variante 3 die einzig ware ;-) wobei ich abhängig von Sinn und Zweck "offene" Attribute nicht mit null sondern mit einem Defaultwert initialisieren würde.


naja, wenn null ein valider Defaultwert ;-)

ich wuerde ebenso die 3. Variante IMMER nehmen, schon um bei mehreren Konstruktoren keinen redudanten Code zu haben bzw eine initialisierung einer variable zu verpassen


----------



## Michael... (24. Jan 2012)

bygones hat gesagt.:


> naja, wenn null ein valider Defaultwert ;-)


Das wurde ja durch meine Aussage nicht ausgeschlossen ;-)


----------



## AngryDeveloper (25. Jan 2012)

irgendjemand hat gesagt.:


> ich würde nicht unbedingt [c]this[/c] verwenden um einen konstruktor zu überladen sondern diese dann auch auschreiben und returnen ... ansonsten bekommst du vom compiler die warnung das mit [c]this[/c] an einem objekt rumspielst was noch nicht völlig initialisiert ist *wesshalb man innerhalb eines konstruktors auch kein [c]this[/c] verwenden sollte*


Grundlagen nachlesen: 6.5.5 Einen anderen Konstruktor der gleichen Klasse aufrufen
Galileo Computing :: Java ist auch eine Insel – 6.5 Objekte anlegen und zerstören


Zum Thema:
Nummer 3. Immer.


----------



## bygones (25. Jan 2012)

irgendjemand hat gesagt.:


> ich würde nicht unbedingt [c]this[/c] verwenden um einen konstruktor zu überladen sondern diese dann auch auschreiben und returnen ... ansonsten bekommst du vom compiler die warnung das mit [c]this[/c] an einem objekt rumspielst was noch nicht völlig initialisiert ist *wesshalb man innerhalb eines konstruktors auch kein [c]this[/c] verwenden sollte*


wie bitte ?
noch nie in meiner Java-Laufbahn diese Meldung gesehen... wenn ich kein this nehmen darf, warum geht dann

```
public Foo(String x) {
 this.x = x;
}

public Foo() {
  this("foo");
}
```
2x this benutzt und das ohne probleme.... was man nicht machen soll ist eine ueberschreibbare Methode innerhalb eines Konstruktors aufrufen, das ist aber etwas anderes


----------



## SilencerandLois (25. Jan 2012)

Erst mal Danke für so viele Antworten 
War schon sehr interessant zu Lesen :toll:




HimBromBeere hat gesagt.:


> EDIT: Ich finde überdies alle drei Varianten ziemlich bescheiden. Ich nehme mal an, dass pX und pY sollen Koordinaten von irgendewas sein, also gleichberechtigt. Warum sollte man dann also eine Instanz mit x- aber ohne y-Koordinate erzeugen dürfen (anderherum jedoch nicht).
> Müsste ich mich entscheiden zwischen Cholera, Pest und SARS würde ich wahrscheinlich für *Variante III stimmen, da hiermit doppelter Code so weit wie möglich vermieden wird *(stell dir mal vor, du müsstest noch mehr Instanzvariablen initialisieren, dann würden da ziemlich viele identische Zeilen mehfrach vorkommen). Machst du die Weiterleitung über this(...) hast du nur diese eine Zeile in ALLEN Konstruktoren.



Okay, über das Beispiel an sich kann man sicherlich streiten. Aber mir ging es jetzt auch hier nicht um ein konkreten Anwendungsfall, sondern allgemein, welche Variante die bessere in einer solchen Situation wäre 

Viele Grüße,
Martin


----------

