In welcher Reihenfolge werden statische Blöcke und Initialisierungsblöcke ausgeführt, wenn Vererbung verwendet wird?

Es gibt mehrere Spielregeln

• statische Blöcke werden immer ausgeführt, bevor das Objekt erstellt wird. Aus diesem Grund werden Drucknachrichten sowohl von übergeordneten als auch von untergeordneten statischen Blöcken angezeigt
• wenn Sie jetzt den Konstruktor der Unterklasse (untergeordnetes Objekt) aufrufen, ruft dieser Konstruktor super(); implizit auf, bevor er seinen eigenen Konstruktor ausführt. Der Initialisierungsblock tritt bereits vor dem Aufruf des Konstruktors in Kraft. Deshalb wird er zuerst aufgerufen. Nun ist Ihr Elternteil erstellt und das Programm kann weiterhin eine Kindklasse erstellen, die denselben Prozess durchläuft. 

Erklärungen:

1. Der statische Block des übergeordneten Elements wird zuerst ausgeführt, da er zuerst geladen ist und statische Blöcke beim Laden der Klasse aufgerufen werden. 

Ich lerne visuell, also hier eine visuelle Darstellung der Reihenfolge, als SSCCE :

public class Example {

  static {
    step(1);
  }

  public static int step_1 = step(2);
  public int step_6 = step(6);

  public Example() {
    step(8);
  }

  {
    step(7);
  }

  // Just for demonstration purposes:
  public static int step(int step) {
    System.out.println("Step " + step);
    return step;
  }
}

public class ExampleSubclass extends Example {

  {
    step(9);
  }

  public static int step_3 = step(3);
  public int step_10 = step(10);

  static {
    step(4);
  }

  public ExampleSubclass() {
    step(11);
  }

  public static void main(String[] args) {
    step(5);
    new ExampleSubclass();
    step(12);
  }
}

Dies druckt:

Step 1
Step 2
Step 3
Step 4
Step 5
Step 6
Step 7
Step 8
Step 9
Step 10
Step 11
Step 12

Beachten Sie, dass die Reihenfolge der static-Teile von Bedeutung ist. Schauen Sie sich den Unterschied zwischen der Reihenfolge der Example-Sachen von static und ExampleSubclass an.

Beachten Sie auch, dass der Instanzinitialisierungsblock unabhängig vom Auftrag immer vor dem Konstruktor ausgeführt wird. Die Reihenfolge ist jedoch zwischen einem Initialisierungsblock und einem Feldinitialisierer wichtig.

Führen Sie nur die erste Kindklasse aus (kommentieren Sie die extend-Klausel), um den einfachen Ablauf zu sehen.

sekunde - gehe zu Statischer Block vs. Initialisierungsblock in Java? & las die akzeptierte Antwort dort.

Bearbeiten:

1. Die Ausführung erfolgt auf SIC-Art - Statisch, (nicht statisch) Initializer & Constructor.
2. (Nicht statisch) Initializer werden in jeden Konstruktor kopiert - An der Spitze! (daher Zeilen 3/4/5/6)
3. Bevor eine Klasse initialisiert wird, muss ihre direkte Oberklasse initialisiert werden - http://docs.Oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4 (daher übergeordnetes statisches Element) Block erscheint zuerst).

Statischer Block in Java wird vor der Hauptmethode ausgeführt. Wenn wir einen statischen Block in der Java-Klasse deklarieren, wird er beim Laden der Klasse ausgeführt. Dies wird mit den statischen Variablen initialisiert. Es wird hauptsächlich in JDBC verwendet. Statischer Block in Java wird jedes Mal ausgeführt, wenn eine Klasse geladen wird. Dies wird auch als statischer Initialisierungsblock bezeichnet. Der statische Block in Java wird initialisiert, wenn die Klasse in den Speicher geladen wird. Dies bedeutet, wenn die JVM den Bytecode liest. Initialisierung kann alles sein; Es kann sich um eine variable Initialisierung oder um etwas anderes handeln, das von allen Objekten dieser Klasse gemeinsam genutzt werden sollte. Statischer Block ist ein normaler Codeblock, der in geschweifte Klammern {} eingeschlossen ist und dem ein statisches Schlüsselwort vorangestellt ist.

also zuerst ein statischer Block ausgeführt.

Instanzinitialisierungsblöcke: Wird jedes Mal ausgeführt, wenn die Instanz der Klasse erstellt wird.

so nächster Initialisierungsblock wird ausgeführt, wenn eine Instanz der Klasse erstellt wird.

dann wird Constructor ausgeführt

• Statische Init-Blöcke werden zum Zeitpunkt des Klassenladens ausgeführt.
• In der Klassenhierarchie beginnt die Reihenfolge für die Ausführung statischer Init-Blöcke mit der obersten Klasse.
• In einer Klasse ist die Reihenfolge für die Ausführung des statischen Blocks von oben nach unten.
• Die obige Regel gilt unabhängig davon, wo der statische Block in der Klasse vorhanden ist.

(In Ihrem Code werden zuerst die übergeordneten statischen Blöcke und dann die untergeordneten statischen Blöcke ausgeführt.)

• Instanz-Init-Blöcke werden nach dem Aufruf von super () ausgeführt. im Konstruktor .
  • Immer super (); ist die allererste Anweisung in einem Standardkonstruktor.

In Ihrem Code, wenn Sie ein untergeordnetes Objekt erstellen: 

• Der Standardkonstruktor der Child-Klasse wird ausgeführt. 
• Es wird das Super anrufen (); Konstrukteur. 
• Dann wird der Superklassenkonstruktor ausgeführt. 
• Die Parent-Klasse führt ihr super () aus. Anruf. 
• Danach werden die Instanz-Init-Blöcke in der Parent-Klasse ausgeführt (von oben nach unten). 
• Dann wird der Code innerhalb des Konstruktors ausgeführt (falls vorhanden). 
• Dann kehrt es zur Child-Klasse zurück und führt die Init-Blöcke der Child-Klasseninstanz aus. 
• Schließlich wird der Code im untergeordneten Konstruktor ausgeführt (falls vorhanden).

Folgendes habe ich gefunden, als ich mich auf eine Zertifizierung vorbereitete.

Während wir eine Klasse ausführen, erfolgt die erste Initialisierung der statischen Blöcke/statischen Variablen. Wenn mehrere statische Blöcke vorhanden sind, wird es in der Reihenfolge ausgeführt, in der es erscheint.

Dann wird es Initialisierungsblöcke/Instanzvariableninitialisierung ausführen. Wenn mehrere Initialisierungsblöcke/Variableninitialisierung vorhanden sind, wird sie in der Reihenfolge ausgeführt, in der sie auftritt

Danach schaut es in den Konstruktor.

Es wäre sehr hilfreich, den Objektkonstruktionsprozess mit einem schrittweisen Debugger zu überprüfen, der eine Ansicht enthält, in der Sie sehen können, wie Ihr Objekt durch die Phasen geht. Ich fand das sehr nützlich, um die Perspektive von einem höheren Standpunkt aus zu klären. Eclipse kann Ihnen dabei helfen, indem Sie den Debugger in die Funktion einsteigen.

Ich wollte nur meine Ergebnisse teilen ... Ich habe in einer Antwort in einem anderen Thread gelesen, dass statische Blöcke zuerst vor statischen Feldern ausgeführt werden, was nicht korrekt ist. Es hängt davon ab, was zuerst kommt: statisches Feld oder statischer Block. Schauen Sie sich den Code unten an. Es wird versucht, die Dinge in die richtige Perspektive zu bringen.

1. JVM sucht nach einer Klasse, die über einen öffentlichen statischen void main (String args []) verfügt, damit diese Klasse geladen werden kann.
2. Anschließend werden statische Felder dieser Klasse initialisiert (wenn sie vor statischen Blöcken stehen). Diese Felder können statische Methoden dieser oder einer anderen Klasse aufrufen. Wenn sie eine statische Methode dieser Klasse aufrufen, wird diese Methode bedient. Wenn sie eine statische Methode einer anderen Klasse aufrufen, werden statische Felder oder Blöcke dieser Klasse (je nachdem, was zuerst eintritt) zuerst initialisiert, dann wird dieser Methodenaufruf ausgeführt.
3. Dann geht es zu statischen Blöcken.

4. Es kommt zurück zur Hauptmethode.

   class TestLab {
   static int method(String a) {
       System.out.println("in static method of TestLab" + " Coming from " + a);
       System.out.println("b is " + b);
       return 6;
   }
   
   static int a = method("Line 11");
   static int b = 7;
   
   TestLab() {
       System.out.println("Inside test lab constructor");
   }
   
   static {
       System.out.println("In static block of TestLab");
   }
   
   }
   
   public class Test1 {
   public static void main(String[] args) {
       System.out.println("inside main method of Test 1");
       int a = TestLab.method("Line 26");
   }
   
   // static Test ref=new Test();
   Test1() {
       System.out.println("Default Constructor of Test1");
   }
   
   {
       System.out.println("In instance block of Test1");
   }
   static int d = TestLab.method("Line 37");
   static int e = methodOfTest1();
   static {
       System.out.println("In Static Block of Test1");
   }
   
   static int methodOfTest1() {
       System.out.println("inside static method:mehtodOfTest1()");
       return 3;
   }
   }
   

Hier ist die Ausgabe:

in static method of TestLab Coming from Line 11
b is 0
In static block of TestLab
in static method of TestLab Coming from Line 37
b is 7
inside static method:mehtodOfTest1()
In Static Block of Test1
inside main method of Test 1
in static method of TestLab Coming from Line 26
b is 7

steuerfluss ist-

statischer Block -> Initialisierungsblock -> und abschließend Konstruktor.

statischer Block -> Dieser statische Block wird ausgeführt nur einmal, wenn das Steuerelement an die Klasse kommt (JVM Diese Klasse laden).

Initialisierungsblock -> Dieser Initialisierungsblock wird immer dann ausgeführt, wenn ein neues Objekt für die Klasse erstellt wird (er wird von der zweiten Anweisung des Konstruktors aus ausgeführt, dann die folgenden Konstruktoranweisungen - remember.) Erste Anweisung des Konstruktors ist Super (). /diese())

Konstruktor -> Wird abgerufen, wenn ein neues Objekt erstellt wird.

1.Statischer Init-Block wird ausgeführt, wenn nur die Klasse geladen wird . Der 2.Init-Block wird jedes Mal ausgeführt, bevor ein Objekt der Klasse erstellt wird.

link: - https://www.youtube.com/watch?v=6qG3JE0FbgA&t=2s

Der statische Block wird ausgeführt, wenn eine Klasse in die JVM geladen wird. Während der Init-Block in den Konstruktor kopiert wird, wird dessen Objekt erstellt und vor der Objekterstellung ausgeführt.