- Freie Blöcke werden in Java in statische freie Blöcke und nicht statische freie Blöcke unterteilt.
- Die Ausführungszeit nicht statischer freier Blöcke beträgt: vor der Ausführung des Konstruktors.
- Die Ausführungszeit statischer freier Blöcke beträgt: Wird ausgeführt, wenn die Klassendatei geladen wird.
- Nicht statische freie Blöcke können mehrmals ausgeführt werden und werden ausgeführt, solange ein Objekt initialisiert ist. Statische freie Blöcke werden jedoch nur einmal ausgeführt, wenn die Klasse geladen wird, und werden im Allgemeinen zum Initialisieren der Werte statischer Variablen von verwendet die Klasse.
- Bei jeder Initialisierung eines Objekts wird ein nicht statischer Block ausgeführt.
- Wenn es um Vererbung geht, gilt Folgendes: Führen Sie zuerst den nicht statischen Block der übergeordneten Klasse aus, dann den Konstruktor der übergeordneten Klasse, dann ihren eigenen freien Block und schließlich ihren eigenen Konstruktor.
- Der Ausführungszeitpunkt des statischen Blocks ist, wenn die Klassendatei nur einmal geladen wird, sodass der statische Block nur einmal ausgeführt wird. Wenn diese Klasse später verwendet wird, wird der statische Block nicht erneut ausgeführt.
- Die Ausführungszeit statischer Blöcke liegt in der Initialisierungsphase nach dem Laden der Klasse. Wenn Sie die Loadclass von ClassLoader verwenden, um die Klasse nur zu laden, ohne sie zu initialisieren, wird die Ausführung des statischen Blocks nicht ausgelöst. Bei Verwendung des Klassenfornamens (String) wird die Standardeinstellung „true“ verwendet, also die Initialisierung. Wenn Sie forname(String name, boolean initialize, ClassLoader Loader) verwenden und initialize auf false setzen, wird der statische Block nicht ausgeführt.
- Die Initialisierungsphase nach dem Ausführen des Klassenladens umfasst: Ausführen der <clinit>-Methode, die die Initialisierungsanweisung der Klassenvariablen und die statische Free-Block-Anweisung enthält. Diese Methode wird vom Java-Compiler nach dem Sammeln von Informationen generiert und kann nicht explizit aufgerufen werden.
Anhand von Beispielen soll Folgendes verdeutlicht werden:
Elternklasse
Kopieren Sie den Codecode wie folgt:
vater.java
öffentlicher Klassenvater {
static{//statischer Block
System.out.println("father'sSTATIC free block running");
}
{//Nicht statischer Block
System.out.println("father'sfree block running");
}
öffentlicher Vater(){
System.out.println("Vaters Konstruktor läuft");
}
}
Unterklasse
Kopieren Sie den Codecode wie folgt:
son.java
öffentlicher Unterricht Sohn verlängert Vater{
static{//statischer Block
System.out.println("son'sSTATIC freier Block läuft");
}
{//Nicht statischer Block
System.out.println("Sohn's Freeblock läuft");
}
öffentlicher Sohn() {
// TODO Automatisch generierter Konstruktor-Stub
System.out.println("Sohn-Konstruktor läuft");
}
}
Die Klasse, in der sich die Hauptfunktion befindet
Kopieren Sie den Codecode wie folgt:
test.java
öffentlicher Klassentest{
public static void main(String[] args) {
Klasse f;
versuchen {
System.out.println("--------beforeload Father--------");
f=Class.forName("freeblock.father");
System.out.println("--------afterload Father---------");
System.out.println("--------beforeinitial parent object--------");
f.newInstance();
System.out.println("--------afterinitial parent object--------");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
} Catch (InstantiationException e) {
e.printStackTrace();
} Catch (IllegalAccessException e) {
e.printStackTrace();
}
Klasse s;
versuchen {
System.out.println("-------beforeload son--------");
s=Class.forName("freeblock.son");
System.out.println("--------afterload son--------");
System.out.println("--------beforeinitial son object----------");
s.newInstance();
System.out.println("--------afterinitial son object-----------");
} Catch (ClassNotFoundException e) {
e.printStackTrace();
} Catch (InstantiationException e) {
e.printStackTrace();
} Catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
Ausführungsergebnis:
--------vor Loadfather--------
STATISCHES kostenloses Blockrunning des Vaters
--------nach Loadfather---------
--------vor dem ersten Vaterobjekt--------
Vaters freier Blocklauf
Vaters Konstrukteur läuft
--------nach dem ersten Vaterobjekt--------
-------vor dem Laden Sohn--------
Der STATISCHE freie Block des Sohnes läuft
--------nach dem Laden Sohn-------
--------vor dem ersten Sonobject---------
Vaters freier Blocklauf
Vaters Konstrukteur läuft
Sohns freier Blocklauf
Der Konstrukteur des Sohnes läuft
--------nach dem ersten Sohnobjekt----------
