In Java werden die Codeblöcke als Codeblöcke bezeichnet und die Codeblöcke können in die folgenden vier Typen unterteilt werden:
1. Einführung
1. Normaler Codeblock:
Methodenkörper der Methode in der Klasse
2. Konstruieren Sie den Codeblock :
Der Konstruktor wird aufgerufen, wenn das Objekt erstellt wird, und er wird jedes Mal aufgerufen, wenn es erstellt wird, wodurch Vorrang vor der Ausführung des Klassenkonstruktors ist.
3.. Statischer Codeblock:
Ein in statischer {} eingewickeltes Code -Snippet wird nur einmal ausgeführt. Statische Codeblöcke haben Vorrang vor der Ausführung von Baublocks.
4. Synchronisieren Sie den Codeblock:
Wenn Sie synchronisierte () {} Codeblöcke in einer Umgebung mit mehreren Threads eingewickelt sind, müssen Sie Operationen auf gemeinsam genutzten Daten gegenseitig ausschließen, da dies ansonsten zu Datenkonsistenz führt. Synchrone Codeblöcke müssen in die Methode geschrieben werden.
2. Ähnlichkeiten und Unterschiede zwischen statischen Codeblöcken und konstruierten Codeblöcken
Ähnlichkeiten: Alle JVMS laden die Klasse und führen aus, bevor der Konstruktor ausgeführt wird. Multiple kann in der Klasse definiert werden. Im Allgemeinen werden im Codeblock einige statische Variablen zugewiesen.
Differenz: Statische Codeblöcke werden vor nicht statischen Codeblöcken ausgeführt. Statische Codeblöcke werden nur einmal im ersten Neuen ausgeführt und danach nicht ausgeführt. Stattdessen werden nicht statische Codeblöcke alle neuen ausgeführt.
Drei. Beispiel
Der gewöhnliche Codeblock: {}, der in einer Methode oder Anweisung angezeigt wird, wird als normaler Codeblock bezeichnet. Die Ausführungsreihenfolge der gewöhnlichen Codeblöcke und allgemeinen Anweisungen wird durch die Reihenfolge festgelegt, in der sie im Code erscheinen, zuerst zuerst erscheinen.
public class test {public static void main (String [] args) {{int x = 3; System.out.println ("Variable x =" + x); } int x = 1; System.out.println ("Variable x =" + x); {int y = 7; System.out.println ("Variable y =" + y); }}} / * * Ergebnisvariable x = 3 im gewöhnlichen Codeblock * Variable x = 1 In der Hauptmethode * Variable y = 7 im gewöhnlichen Codeblock * /Konstrukte -Code -Block: Ein Codeblock, der direkt in der Klasse definiert ist und kein statisches Schlüsselwort hat, wird als {} Konstrukt -Codeblock bezeichnet. Der Konstruktorcodeblock wird beim Erstellen eines Objekts aufgerufen, und jedes Mal, wenn das Objekt erstellt wird, wird er aufgerufen, und die Ausführungsreihenfolge des Konstruktorcodeblocks hat Vorrang vor dem Klassenkonstruktor. Wenn mehrere konstruierte Codeblöcke vorhanden sind, wird die Ausführungsreihenfolge durch die Reihenfolge ermittelt, in der sie im Code angezeigt werden, erstmals erste Ausführung angezeigt.
public class test1 {{system.out.println ("erster Baustein");} public test1 (int i) {System.out.println ("Th" + i + "sub-call" + "Konstruktor");} {System.out.Out.println ("zweite Baustein"); Test1 (2);}}/** Ausführungsergebnis Erster Baustein* Zweiter Baustein* 0. Anrufkonstruktor* Erster Baustein* Zweiter Baustein* Erster Baustein* Erster Baustein* Erster Baustein* Zweiter Baustein* Der zweite Anruf zum Konstruktion der Methode*//////Statischer Codeblock: Ein Codeblock, der mit dem statischen Schlüsselwort in Java deklariert wird. Statische Blöcke werden verwendet, um Klassen zu initialisieren und die Attribute der Klasse zu initialisieren. Jeder statische Codeblock wird nur einmal ausgeführt. Da das JVM beim Laden der Klasse statische Codeblöcke ausführt, werden die statischen Codeblöcke vor der Hauptmethode ausgeführt.
Wenn die Klasse mehrere statische Codeblöcke enthält, wird sie zuerst ausgeführt, dann wird der definierte Code später ausgeführt.
Beachten:
1. Statische Codeblöcke können in keiner Methodekörper existieren.
2. Statische Codeblöcke können nicht direkt auf Instanzvariablen und Instanzmethoden zugreifen und über das Instanzobjekt der Klasse zugegriffen werden müssen.
public class test3 {public static String static_field = "static Attribut"; // static block static {System.out.println (static_field); System.out.println ("static Code Block 1");} public String field = "nicht statische Attribut"; // nicht statische Blocks. 2 ");} public initoDerTest () {System.out.println (" No Parameter Constructor ");} public static void main (string [] args) {initoToTest Test = new initoDoTestEST ();} // Nicht-statische Block {System.Out.println (Field). {System.out.println(STATIC_FIELD);System.out.println("static code block 2");}}/* * Run result static attribute* Static code block 1 * Static attribute* Static code block 2 * Non-static attribute* Non-static code block 2 * Non-static attribute* Non-static code block 1 * Non-argument constructor*/Der folgende Code zeigt die vorrangige Beziehung zwischen den einzelnen Codeblöcken beim Erstellen eines Objekts und dem Aufrufen einer Methode:
public class Person {static {System.out.println ("1. Ich bin ein statischer Block, der Vorrang vor der Ausführung des Blockblocks hat! Und es wird nur einmal ausgeführt, wenn das erste Objekt erstellt wird!"); Funktion1 () {System.out.println ("Ich bin ein normaler Codeblock in einer nicht statischen Methode, was Vorrang hat, wenn die Methode aufgerufen wird!");} public static void function2 () {system.out.println ("Ich bin ein normaler Codeblock in einer statischen Methode.Testklasse:
public class hellowrold {public static void main (String [] args) {new Person (). Funktion1 (); neu Person (). Function1 (); =================================================================== =================================================================== ================================================================= =================================================================== =================================================================== ===================================================================Auslaufergebnisse:
Wir können sehen, dass statische Blöcke immer zuerst ausgeführt werden und nur einmal ausgeführt werden, wenn die erste Instanz der Klasse erstellt wird. Der zweite ist der Konstruktorblock; und die dritte ist die Konstruktormethode.
Zusammenfassen
Das obige dreht sich alles um die detaillierte Erklärung der vier Codeblöcke in Java, und ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!