Dans quel ordre les blocs statiques et les blocs d'initialisation s'exécutent-ils lorsqu'on utilise l'héritage?

il y a plusieurs règles en jeu

• les blocs statiques sont toujours lancés avant que l'objet ne soit créé, c'est pourquoi vous voyez des messages imprimés des deux parents et des blocs statiques enfants
• maintenant, lorsque vous appelez le constructeur de la sous-classe (child), alors ce constructeur appelle implicitement super(); avant d'exécuter son propre constructeur. L'initialisation du bloc entre en jeu avant même l'appel du constructeur, c'est pourquoi il est appelé en premier. Donc maintenant votre parent est créé et le programme peut continuer à créer la classe de l'enfant qui subira le même processus.

explications:

1. le bloc statique de parent est exécuté en premier parce qu'il est chargé en premier et les blocs statiques sont appelés lorsque la classe est chargée.

j'apprends visuellement, donc voici une représentation visuelle de l'ordre, comme un 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);
  }
}

Cette affiche:

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

Gardez à l'esprit que l'ordre de la static partie des sujets; regarder en arrière à la différence entre l'ordre de Example 's static choses " et ExampleSubclass .

notez aussi que le bloc d'initialisation de l'instance est toujours exécuté avant le constructeur, peu importe l'ordre. Cependant, l'ordre importe entre un bloc d'initialisation et un initialiseur de champ.

Première de la classe enfant seul (commentaire de l'étendue de la clause) pour voir le simple flux.

Edit:

1. Exécution qui se passe dans le SIC façon Statique, (non statique) Initialiseur & Constructeur.
2. (non statique) initialiseur sont copiés dans chaque constructeur - au sommet! (d'où les lignes 3/4/5/6)
3. avant qu'une classe soit initialisée, sa superclasse directe doit être initialisée - http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4 (donc le blocage statique parent apparaît en premier).

bloc statique en java est exécuté avant la méthode principale. Si nous déclarons un bloc statique dans la classe java, il est exécuté lorsque la classe se charge. Ceci est initialisé avec les variables statiques. Il est principalement utilisé en JDBC. Le bloc statique en java est exécuté chaque fois qu'une classe se charge. Ceci est également connu comme initialisation Statique bloc. Le bloc statique en java initialise quand la classe charge dans la mémoire , cela signifie Quand JVM lit le code octet. L'initialisation peut être n'importe quoi; elle peut être l'initialisation variable ou autre chose qui doit être partagée par tous les objets de cette classe. Static block est un bloc normal de code enfermé dans des accolades { } et est précédé par un mot-clé statique.

donc bloc statique exécuté en premier.

blocs D'initialisation D'Instance: exécute chaque fois que l'instance de la classe est créée.

donc bloc D'initialisation suivant exécuté lorsque l'instance de la classe est créée.

puis constructeur exécuté

• les blocs D'initialisation statiques sont exécutés au moment du chargement de la classe.
• dans la hiérarchie des classes, l'ordre d'exécution des blocs d'initialisation statiques part de la classe supérieure.
• dans une classe l'ordre pour l'exécution de bloc statique est de haut en bas.
• la règle ci-dessus s'applique quel que soit l'endroit où le bloc statique est présent dans la classe.

(dans votre code le parent blocs statiques seront exécutés en premier, et ensuite, l'enfant de la classe blocs statiques.)

• les blocs D'Instance init seront exécutés après l'appel au super(); dans le constructeur.
  • Always super(); est la toute première déclaration dans un constructeur par défaut.

dans votre code lorsque vous créez un objet enfant:

• Le constructeur par défaut de l'Enfant classe exécutée.
• il appellera le super(); constructeur.
• puis le constructeur super class est exécuté.
• la classe mère exécutera son super(); call.
• après cela les blocs INIT de l'instance dans la classe mère sont exécutés.(De haut en bas).
• puis le code dans le constructeur est exécuté (s'il y en a).
• alors il reviendra à la classe enfant et exécuter les blocs D'initialisation de la classe enfant.
• enfin le code du constructeur enfant est exécuté (s'il existe).

il serait très utile de vérifier le processus de construction de l'objet avec un débogueur étape par étape, ayant une vue dans laquelle vous pouvez voir comment votre objet passe à travers les phases. J'ai trouvé cela très utile pour clarifier la perspective d'un point de vue supérieur. Eclipse peut vous aider avec cela avec son débogueur step into function.

je voulais Juste partager mes découvertes. J'ai lu dans l'une des réponses sur un autre thread que les blocs statiques sont exécutés avant les champs statiques ce qui n'est pas correct. Cela dépend de qui vient en premier, champ statique ou statique bloc. Jetez un oeil au code ci-dessous. Il essaiera de mettre les choses en perspective.

1. JVM recherche une classe qui a une chaîne de caractères args(public static void main) afin qu'elle puisse charger cette classe.
2. il initialise alors les champs statiques de cette classe(s'ils viennent avant les blocs statiques). Ces champs peuvent appeler les méthodes statiques de cette classe ou d'une autre. S'ils appellent méthode statique de cette classe alors cette méthode est servie. S'ils appellent la méthode statique d'une autre classe, alors les champs statiques ou les blocs de cette classe(selon ce qui vient en premier) sont initialisés en premier, alors cet appel de méthode est servi.
3. puis, il se déplace vers les blocs statiques.

4. Il s'agit retour à la page principale méthode.

   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;
   }
   }
   

Voici la sortie:

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

voici ce que j'ai trouvé en préparant une certification.

pendant que nous exécutons une classe, les premiers blocages statiques/ initialisation des variables statiques se produisent. Si plusieurs blocs statiques sont présents, il l'exécutera dans l'ordre où il apparaît,

ensuite il exécutera INIT blocks/ instance variable initialisation.Si plusieurs blocs d'initialisation/ initialisation de variables sont présents, il l'exécutera dans l'ordre où il apparaît,

ensuite, il examinera le constructeur.

static block est exécuté lorsqu'une classe est chargée dans JVM. Tout init bloc est copié dans le Constructeur, dont l'objet sera créé et s'exécute avant la création de l'objet.

le débit de commande est -

statique bloc -> Initialisation du bloc -> et enfin Constructeur.

bloc statique - > ce bloc statique sera exécuté une seule fois lorsque la commande vient à la classe.(JVM Charge cette classe)

bloc D'initialisation -> ce bloc D'initialisation sera exécuté chaque fois qu'un nouvel objet créé pour la classe (It sera exécuté à partir de la deuxième déclaration du constructeur, puis à la suite des déclarations du constructeur-rappelez-vous que la première déclaration du constructeur sera Super () / ceci())

Constructor -> ce sera obtenu chaque fois qu'un nouvel objet est créé.