# statischer Konstruktor



## Dwaine (16. Dez 2003)

Was ist ein statischer Konstruktor?Wann wird er aufgerufen und vorallem wie wird er erstellt? Und was ist generell der Unterschied zwischen statisch und dynamisch. :?:  :?:  :?: 

Danke schon ma im voraus.


----------



## Stefan1200 (16. Dez 2003)

Kontruktoren werden immer aufgerufen, wenn eine Klasse aufgerufen wird.
Kontruktoren haben den selben Namen wie die Klasse.

Zu den anderen Fragen möchte ich doch glatt abgegeben an meine Forum Kollegen ;-)


----------



## Zaron (16. Dez 2003)

static darf soweit ich weiß garnicht vor den Konstruktor einer Klasse gesetzt werden (wäre ja auch blöd, da der Konstruktor ja eine Instanz der Klasse erzeugt und Instanzen sind nicht statisch *g* )

static bedeutet, dass die Methode (oder Variable) zur Klasse gehört was sich wie folgt äußert:  Klassenname.statischeMethode(); anstelle von objektname.methode();


----------



## Ebenius (16. Dez 2003)

> Was ist ein statischer Konstruktor?


Meinst Du vielleicht nicht "Konstruktor" sondern _static initializer_s?

Es grüßt Ebenius


----------



## jptc.org (17. Dez 2003)

So ich versuche mal zusammenzufassen  . 

Also statische Konstruktoren gibt es nicht! Alles was statisch (static) an einer Klasse ist, ist nicht an eine konkrete Objektinstanz der Klasse gebunden. Am besten sieht man das bei statischen Variablen. Wenn man zwei Instanzen einer Klasse hat und in einer Klasse eine statische Variable ändert, so ist die Änderung auch sofort in der zweiten Instanz der Klasse zu sehen. D.h. static Variable werden pro Klasse und nicht pro Instanz gespeichert.

Um eine Instanz einer Klasse anzulegen werden Konstruktoren verwendet. Erbt eine Klasse von einer anderen, so werden beim Instanziieren immer auch die entsprechenden Konstruktoren der Superklasse aufgerufen. Es wird also einfach die Hierarchie nach oben gewandert, dabei werden immer die Konstruktoren mit den gleichen Parametern verwendet, es sei denn man ruft selbst super() mit einer anderen Parameterzahl auf.

Statische Codeblöcke und Variablen werden nach dem Aufruf der Konstruktorhierarchie, aber vor dem ersten Aktion nach super() initialisiert.

Ich hoffe das hat etwas zur Verwirrung beigetragen.

Karsten Voigt
http://www.java-performance-portal.org


----------



## me.toString (17. Dez 2003)

Ich denke mal das nicht eine statische Methode gmeint ist sondern ein staic-Block !

```
public class Test {

  static{
    //irgendwelche Anweisungen
  }

  // ...
}
```

Sieht doof aus ... geht aber. Dieser Block wird dann *ein einziges mal * aufgerufen ... weiss allerdings nicht wann  ... ob ganz am Anfang beim Programmstart oder bei der ersten Benutzung der Klasse. Man kann diesen Block auch *nicht * händisch noch mal aufrufen !

Michael


----------



## jptc.org (17. Dez 2003)

das hab ich auch mit in meinem letzten post gesagt:



			
				jptc.org hat gesagt.:
			
		

> Statische Codeblöcke und Variablen werden nach dem Aufruf der Konstruktorhierarchie, aber vor dem ersten Aktion nach super() initialisiert.



man sollte aber immer dran denken: statische codeblöcke sind kein guter programmierstil und für aussenstehende häufig schwer zu verstehen!

Karsten Voigt
http://www.java-performance-portal.org


----------



## me.toString (17. Dez 2003)

@karsten:
Sorry ... wir haben unsere Beiträge zur selben Zeit geschrieben [ du warst nur etwas schneller beim einchecken ...  :? ]

Michael


----------



## Dwaine (17. Dez 2003)

Jo dann vielen dank erstmals.
Kann noch nich sagen ob mir das weiterhilft, werde ich morgen sehn.  
bis denne


----------



## Ebenius (18. Dez 2003)

Also:
	
	
	
	





```
static {
      // something
}
```
nennt sich _static initializer_. Der Grund dafür ist, dass statisch (also für die Klasse und nicht Instanzen der Klasse) Initialisierungen vorgenommen werden.

_Static initializers_ sind statische Klasseninhalte und werden im Zuge der Initialisierung der Klasse aufgerufen; in der Reihenfolge wie sie im Code deklariert sind (v.o.n.u.). Das bedeutet nach dem Laden der Klasse werden alle _static_s der Reihe nach aufgeführt:

```
static {
    System.out.println("First Initialization");
}

static {
    System.out.println("Second Initialization");
}
```
führt definitiv zu einer Ausgabe auf dem Standard Out von:

```
First Initialization
Second Initialization
```

Hat man jetzt eine Klassen-Hierarchie mit _static initializer_s in erbender und beerbter Klasse
	
	
	
	





```
class A {
    static {
        System.out.println("Class A initializing...");
    }
}

class B extends A {
    static {
        System.out.println("Class B initializing...");
    }
}
```
führt dies definitiv zu einer Ausgabe auf dem Standard Out von:
	
	
	
	





```
Class A initializing...
Class B initializing...
```

Eine Klasse wird initialisiert, bevor Sie das erste mal benutzt wird. Das heißt, dass vor dem ersten Erstellen einer Instanz (Konstruktor-Aufruf), vor dem ersten Aufruf einer statischen Methode und vor dem ersten Abgreifen einer statischen Variable (oder Konstante) die Klasse initialisiert ist.

Das sind alle Regeln, die ich kenne.

 :!: _A.class_ ist keine Nutzung der Klasse im eigentlichen Sinn. Abhängig vom Compiler ist die Klasse dadurch initialisiert oder auch nicht. Streng nach der Maschinenspezifikation wird Klasse _A_ dadurch nicht initialisiert, obwohl ältere Compiler dies anders sehen...

Es grüßt Ebenius


----------

