# Initialisierung nur im Konstruktor?



## Verjigorm (3. Mai 2007)

Hi, ich hab mal wieder eine Frage 

und zwar haben wir eine Klasse, deren Konstruktor NICHTS übergeben bekommt.
Initialisiere ich dann Werte trotzdem im Konstruktor oder in der Variablendeklaration?
Und wenn ja worin liegt denn der Unterschied? Hab mich zwar nochmal bissl belesen, aber nen wirklich guten Grund konnt ich nicht finden

Bsp:


```
public class Abc1{

private int i = 0;

public Abc1()
{}
...
}
```

oder


```
public class Abc2{

private Abc1 abc1 = null;

public Abc2()
{
abc1 = new Abc1();
}
...
}
```

und beim 2. Beispiel habe ich mal gehört, dass man Variablen/Objekt etc. immer mit
*null* initialisieren soll, ist da was dran?


mfg Verjigorm


----------



## Guest (3. Mai 2007)

Hi,

also zwingend vorgeschrieben ist das nicht und einen großen Unterschied macht es auch nicht. Ich persönlich bevorzuge aber auch die Initialisierung im Konstruktor, der besseren Lesbarkeit halber.

Das hier 


```
int i = null;
```

geht aber definitiv nicht, da int ein primitiver Typ ist. 

Ich weis aber was du meinst, aber auch das ist nicht notwendig, deklarierte Objekte sind per default null.


----------



## L-ectron-X (3. Mai 2007)

Grundsätzlich dient der Konstruktor zur Initialisierung von Variablen einer Klasse, egal, ob ihm Parameter übergeben werden, oder nicht.



			
				Verjigorm hat gesagt.:
			
		

> und beim 2. Beispiel habe ich mal gehört, dass man Variablen/Objekt etc. immer mit
> 
> ```
> int i = null;
> ...



Der Code ist Quatsch.  Wenn dann so:

```
int i = 0;
```

Zur Frage: In Methoden ist es wichtig die Variablen zu initialisieren.
Instanzvariablen hingegen werden vom Konstruktor mit Defaultwerten initialisiert, solange der Programmierer nicht selbst Werte vorgibt.


----------



## Verjigorm (3. Mai 2007)

ok das Beispeil mit i = null war Müll 
ich meinte das bezogen auf z.b. Objekte

und die sind per default *null* ?
ich dachte da gabs nen Unterschied zwischen "nicht initalisiert" und "null-gesetzt"

edit: gefunden Rechtschreibfehler dürfen behalten werden 
edit2: das is mein erstes Projekt, bei dem auch diverse Programmierkonventionen mitberücksichtigt werden, deswegen muss ich mal anfangen mehr Dinge genauer richtig zu machen


----------



## L-ectron-X (3. Mai 2007)

Verjigorm hat gesagt.:
			
		

> und die sind per default *null* ?
> ich dachte da gabs nen Unterschied


Dazu mal ein kleines Programm:

```
public class NullTest {
   private String str;
   private int i;
   private double d;
   private boolean b;
   
   public NullTest() {
      System.out.println(str);
      System.out.println(i);
      System.out.println(d);
      System.out.println(b);
   }
   
   public static void main(String[] args) {
      new NullTest();
   }
}
```



			
				Verjigorm hat gesagt.:
			
		

> edit: gefunden Rechtschreibfehler dürfen behalten werden


Nee danke, ich sammle aus den anderen Postings schon genug ein. :wink:


----------



## Guest (3. Mai 2007)

Initialisierung mit 0 oder null ist überflüssig, da es per Default diesen Wert annimmt.
Sollten andere Werte als die Defaultwerte genommen werden, dann im entsprechenden Konstruktor 
setzen, da sonst unnötigerweise eine Initialisierung stattfindet, die direkt verworfen wird.


----------



## Guest (3. Mai 2007)

> und die sind per default null ?
> ich dachte da gabs nen Unterschied zwischen "nicht initalisiert" und "null-gesetzt"



Also ich weis nicht, ob das in irgendeiner Spezifikation steht aber aus der Erfahrung kann ich sagen, das deklarierte Objekte null sind, soweit nichts anderes zugewiesen wurde. Ich kenne das allerdings auch noch von "früheren" (Assembler-)Zeiten, daß man sagte, daß zugewiesener Speicher zufälligen Inhalt haben kann und er deshalb auf 0 zu setzen ist, ich denke das ist aber mittlerweile obsolet. Das würde ja in Bezug auf Java bedeuten, das ein deklarieretes Objekt eine zufällige Instanz besitzen könnte.


----------



## NTB (3. Mai 2007)

Hmm, ich komme gerade ein bischen ins Straucheln. So wie ihr es sagt, wird ein Objekt bei der Deklaration mit null initialisiert.
Das stimmt doch aber gar nicht. Ehrlich gesagt, ist mir das grad nicht so ganz klar, fakt ist ja aber, dass bei folgendem der Compiler meckert, dass der String nicht initialisiert wurde:


```
public String getMyString() {
   String foo;
   return foo;
}
```

Ergo zeigt ein deklariertes Objekt auf keine Speicheradresse und liefert deswegen null, wurde aber nicht initialisert? 

Bei dem folgenden meckert der Compiler nicht mehr:

```
public String getMyString() {
   String foo = null;
   return foo;
}
```

Aber wenn ich String = null setze, ist das doch keine Initialisierung!?

Hmm...

Also die Frage, die ich mir Stelle, ist, ob es korrekt ist, zu sagen: "Das Objekt wurde mit null *initialisiert*". Ich denke, die Antwort lautet nein. Sehe ich das richtig?


----------



## Guest (3. Mai 2007)

In Methoden sieht das ganze wiederum anders aus, da gilt eine nicht weiter definierte Instanz für den Compiler als Problem, frag mich nicht, was genau den Unterschieschied ausmacht.


----------



## NTB (3. Mai 2007)

Hmm, ich vermute, dass der Unterschieschied [sic!] ganz einfach nur darin liegt, dass der Comiler das in einer Methode direkt erkennen kann. Sonst eben nicht... aber das ist nur meine Vermutung.


----------



## Guest (4. Mai 2007)

Danke, daß du meinen Vertipper nochmal hervorgehoben hast.  :roll:


----------



## NTB (4. Mai 2007)

Sry, war wirklich nicht bös gemeint. Ich bin grad ein bischen lustig drauf


----------



## Guest (4. Mai 2007)

Ok, dann sei es dir verzeihen.


----------



## Gast09 (4. Mai 2007)

ob du eine variable direkt oder initialisierst oder im konstruktor ist egal, da der java compiler die initialisierung für dich in den konstruktor tut, es ist also nur syntaktischer zucker die ausserhalb zuinitialisieren

Zum null Problem, jede Objektreferenz hat genau zwei Zustände: null oder eine gültige Referenz.

Im Stringbeispiel bekommst du bloss einen Hinweis vom Compiler das der variable uninitialisiert ist, da das der Compiler erkennt. Und deswegen musst du sie extra auf null zuweisen um deutlich zumachen, dass das von dir erwünscht ist


----------



## Leroy42 (4. Mai 2007)

Gast09 hat gesagt.:
			
		

> Und deswegen musst du sie extra auf null zuweisen um deutlich zumachen, dass das von dir erwünscht ist



Wobei ich bis heute nicht verstehe, *warum* das so ist.

Was spricht eigentlich dagegen, lokale Variablen (Methoden, Blöcke) genau
wie Instanzvariablen automatisch zu initialisieren?  ???:L


----------

