Die 2 Phasen der Klassen-Initialisierung im Java Programm
Die Java Klassen Initialisierung durchläuft zwei Phasen.
Diese beiden Phasen sind im Grunde genommen, wie die Phasen 2 und 3 bei der Instanz-Initialisierung.
Inhalt
In Phase eins werden die Klassenvariablen der entsprechenden Java Klassen angelegt
Das heißt diese werden deklariert.
Schau dir den folgenden Code dazu an.
Uns interessiert jetzt erst einmal nur die Klassenvariable x.
public class KlassenInitialisierung {
public static int x=5; //statische Variable vom Datentyp Integer
int y; //Instanzvariable vom Datentyp Integer
public static void main (String [] args){
}
}
Es wird also java intern ein Speicherplatz für die Variable x reserviert.
Die Größe des reservierten Speicherplatzes ist wieder abhängig vom jeweiligen Datentyp.
Und das war es dann auch schon mit Phase eins.
In Phase zwei wird der Variablen dann ein Wert zugewiesen und es werden Methoden gepackt.
Jetzt, in Phase zwei, wird der Klassenvariablen der entsprechende Wert zugewiesen.
public class KlassenInitialisierung {
public static int x=5; //Zuweisung des Wertes 5 in Phase zwei der Java Klassen Initialisierung
int y; //Instanzvariable vom Datentyp Integer
public static void main (String [] args){
}
}
Das bedeutet:
Erst in Phase zwei bekommt die Variable den Wert 5 zugewiesen.
Außerdem werden jetzt die Instanzmethoden angelegt.
In diesem Beispiel siehst du die Instanzmethode zunehmenWerte(), welche den Wert der Instanzvariable erhöht.
public class KlassenInitialisierung {
public static int x=5; //statische Variable vom Datentyp Integer
int y; //Instanzvariable vom Datentyp Integer
public void zunehmenWerte(){ //Instanzmethode erhöht den Wert der Instanzvariablen
y=y+22;
System.out.println(y);
}
public static void main (String [] args){
}
}
Diese Methode wird jetzt java-intern als statische Methode gewandelt.
Diese würde dann als Argument ein Objekt der Klasse erwarten und die Instanzvariablen des Objektes erhöhen.
In diesem Fall heißt das Argument bzw. Variable ganz einfach „wert“.
Und diese Variable ist vom Datentyp „KlassenInititialsierung“.
public class KlassenInitialisierung {
public static int x=5; //statische Variable vom Datentyp Integer
int y; //Instanzvariable vom Datentyp Integer
public void zunehmenWerte(){ //Instanzmethode
y=y+22; //Erhöhung der Instanzvariablen
System.out.println(y); //Rückgabe von y
}
public static void zunehmenWerte(KlassenInitialisierung wert){ //abgewandelte Klassenmethode
wert.y=wert.y+22; //Erhöhung der Instanzvariablen
System.out.println(wert.y); //Rückgabe von y
}
public static void main (String [] args){
KlassenInitialisierung objektEins = new KlassenInitialisierung(); //Objekt erzeugen
objektEins.zunehmenWerte(); //Aufruf der Instanzmethode
zunehmenWerte(objektEins); //Aufruf der Java Klassen Methode
}
}
Klar ist, dass beide Methoden genau das Gleiche machen.
Rufe doch, so wie ich auch, beide Methoden einmal in der main-Methode auf und klicke auf „Run“.
Die Instanzvariable y wurde genau zweimal um 22 erhöht.
Nicht schlecht, oder?
Und genau das macht Java mit Instanzmethoden.
Intern werden diese bei der Klassen Initialisierung als statische Methoden gewandelt und geführt.
Das ganze spielt für dich erst einmal keine Rolle.
Was aber durchaus wichtig ist, ist der Unterschied zwischen der Instanz-Initialisierung und der Klassen-Initialisierung.
Also, worin liegt jetzt der Unterschied zur Instanz Initialisierung
Oder warum ist es wichtig, diese Phasen zu kennen.
Klar bei der Instanzinitialisierung durchläuft das Programm 4 Phasen.
Aber es gibt noch einen anderen Unterschied.
Und zwar, wie oft diese Phasen durchlaufen werden.
Ich verwende einmal zwei Codeblöcke um dies besser zu verdeutlichen.
public class KlassenInitialisierung {
public static int x=5; //statische Variable vom Datentyp Integer
int y; //Instanzvariable vom Datentyp Integer
{ //nicht statischer Initialisierungsblock
System.out.println("Instanzinitialisierung abgeschlossen");
}
static { //statische Initialsierungsblock
System.out.println("Klasseninitialisierung abgeschlossen");
}
public static void main (String [] args){
KlassenInitialisierung objektEins = new KlassenInitialisierung(); //Objekt erzeugen
KlassenInitialisierung objektZwei = new KlassenInitialisierung(); //neues Objekt erzeugen
}
}
Der erste Codeblock ist statisch. Dieser erzeugt die Bildschirmausgabe „Die Klasseninitialisierung ist abgeschlossen“.
Der zweite Codeblock ist nicht statisch. Dieser dient der Objekt- oder Instanzinitialisierung.
Wenn du jetzt innerhalb der main Methode zwei Objekte anlegst und dann auf „Run“ klickst…
Ja dann werden beide Initialisierungsblöcke durchlaufen.
Wichtig dabei ist, dass die Klasseninitialisierung nur einmal durchlaufen wird.
Und zwar genau dann, wenn die Klasse das aller erste Mal angesprochen wird.
Die Instanzinitialisierung wird aber bei jedem neuen Objekt durchlaufen.
Außerdem findet die Klasseninitialisierung vor der Objektinitialisierung statt.
Zusammenfassung:
- Java Klassen werden initialisiert. Das bedeutet, sie werden intern angelegt.
- Die ganze Java Klassen Initialisierung durchläuft zwei Phasen.
- In Phase 1 werden die Klassenvariablen angelegt und in Phase zwei werden ihnen die entsprechenden Werte zugewiesen.
Über den Autor
