While reading the book of Ekkel, I came across one moment that I cannot understand. The following code is presented:

import static net.mindview.util.Print.*; class Insect { private int i = 9; protected int j; Insect() { print("i = " + i + ", j = " + j); j = 39; } private static int x1 = printInit("static Insect.x1 initialized"); static int printInit(String s) { print(s); return 47; } } public class Beetle extends Insect { private int k = printInit("Beetle.k initialized"); public Beetle() { print("k = " + k); print("j = " + j); } private static int x2 = printInit("static Beetle.x2 initialized"); public static void main(String[] args) { print("Beetle constructor"); Beetle b = new Beetle(); } }

OUTPUT:

 static Insect.x1 initialized static Beetle.x2 initialized Beetle constructor i = 9, j = 0 Beetle.k initialized k = 47 j = 39

I always thought that before calling the constructor, the class fields should be initialized so that in case of a call to an uninitialized variable in the constructor, I do not get an exception. Following this logic, the output to the screen of the inscription "Beetle.k initialized" should have been after the output of the "Beetle constructor" . Forgive help to understand. Thank.

    3 answers 3

    The order of initialization is as follows:

    1. Parent Static Items
    2. Static elements of the heir
    3. Parent global variables
    4. Parent constructor
    5. Heir global variables
    6. Heir constructor

    Example

     class Insect { private int i = 9; [9] protected int j; [10] Insect() { [8] print("i = " + i + ", j = " + j); [11] j = 39; [12] } private static int x1 = printInit("static Insect.x1 initialized"); [2] static int printInit(String s) { [3] print(s); return 47; } } public class Beetle extends Insect { private int k = printInit("Beetle.k initialized"); [13] public Beetle() { [7] print("k = " + k); [14] print("j = " + j); [15] } private static int x2 = printInit("static Beetle.x2 initialized"); [4] public static void main(String[] args) { [1] print("Beetle constructor"); [5] Beetle b = new Beetle(); [6] } }
    • 2
      It would also be nice to point out that static variables (and indeed all static content) are initialized when the Loader class first comes across this class. And all the other variables when you call the constructor. - Vartlok
    • 2
      @Nara that's right. If this is not done manually, the compiler itself writes the call to the parent constructor without arguments. - LEQADA
    • one
      @Nara, you are embarrassed by the fact that I have specified the constructor of the parent before the heir? The fact is that first of all, when reading the constructor of the heir, the constructor of the parent is called. So it's fairer to write that way. - LEQADA
    • one
      @Nara, that's right. - LEQADA
    • one
      @Nara, I added a call-order code to the response. - LEQADA 2:49

    The order of initializing an object instance is described in JLS (12.5 Creation of New Class Instances) (my translation):

    When creating a new instance of a class, memory is allocated for all instance variables declared in the class and for all instance variables declared in each superclass, including all hidden variables (§8.3).

    If memory cannot be allocated due to lack of free space, instance creation is interrupted with an OutOfMemoryError . Otherwise, all instance variables of the new object, including those declared in the superclass, are initialized with default values. (§4.12.5).

    Before a reference to the created object is returned, the specified constructor is executed to initialize a new object using the following algorithm:

    1. Assign constructor arguments to the parameter variables for invoking this constructor.
    2. If the constructor starts with an explicit call (§8.8.7.1) of another constructor of the same class (using this ), then you need to calculate the arguments and execute that constructor recursively using the same 5 steps. If the execution of that constructor is interrupted (completes abruptly), then this algorithm will be interrupted for the same reasons, otherwise proceed to step 5.
    3. If the constructor does not start with an explicit call to another constructor of the same class (using this ), then for classes other than Object constructor of the superclass is explicitly or implicitly called (using super ). It is necessary to calculate the arguments and execute the superclass constructor recursively using the same 5 steps. If the execution of that constructor is interrupted (completes abruptly), then this algorithm will be interrupted for the same reasons, otherwise proceed to step 4.
    4. Execute instance initializers and instance variable initializers for this class, assigning the values ​​of the instance variable initializers to the corresponding instance variables, from left to right in order of appearance in the source code of the class. If the execution of any initializer causes an exception, the following initializers are not processed, and this algorithm ends with the same exception. Otherwise, go to step 5.
    5. Run the rest of the constructor body. If execution is interrupted, this algorithm will be interrupted for the same reasons. Otherwise, the algorithm will complete normally.

    Unlike C ++, Java does not set up separate rules for dispatching methods when creating a new instance of a class. If the methods overridden in the inheritors in the object being initialized are called, these overridden methods are used until the new object is fully initialized.

    The class initialization order is described in JLS (12.4. Initialization of Classes and Interfaces) :

    Class initialization consists of executing its static initializers and initializers for static fields (class variables) declared in a class.

    Interface initialization consists of the execution of field initializers (constants) declared in the interface.

    The class or interface T will be initialized immediately before one of the following events:

    • T is a class and an instance of class T .
    • A call to a static method declared in T
    • Assignment is performed to a static field declared in T
    • A static field declared in T used and this field is not a constant (§4.12.4) (constant is a final variable of primitive type or String declared with an initializer that is a constant expression)
    • T is the top-level class (§7.6) and the expression assert (assert statement) (§14.10) is lexically located inside T (§8.1.3).

    When a class is initialized, its superclasses are initialized (if they have not been initialized before); Superinterfaces are also initialized (§8.1.5) if they declare default methods (§9.4.3) (if they have not been initialized). The initialization of the interface does not in itself cause the initialization of its superinterfaces.

    A static field access (§8.3.1.1) causes initialization only for the class or interface that declared the field, even if the call was made using the name of a subclass, subinterface, or class that implements the interface.

    Calling some methods from the Class Class and the java.lang.reflect also cause initialization of the class or interface.

    The class or interface will not be initialized under other circumstances.

    The goal is for initializers of a class or interface to translate it into a consistent state, and this state is the first state to be seen from other classes. Static initializers and initializers of class variables are executed in order of appearance in the text, and cannot refer to class variables declared in the text after use, despite the fact that these class variables are in scope (§8.3.3). This restriction is designed to detect cyclic or other incorrect initialization at the compilation stage.

    Armed with this clumsy translation, let's see what happens in your example:

     import static net.mindview.util.Print.*; class Insect { private int i = 9; protected int j; Insect() { print("i = " + i + ", j = " + j); j = 39; } private static int x1 = printInit("static Insect.x1 initialized"); static int printInit(String s) { print(s); return 47; } } public class Beetle extends Insect { private int k = printInit("Beetle.k initialized"); public Beetle() { print("k = " + k); print("j = " + j); } private static int x2 = printInit("static Beetle.x2 initialized"); public static void main(String[] args) { print("Beetle constructor"); Beetle b = new Beetle(); } }

    OUTPUT:

     // Вызывается статический метод класса Beetle.main // Начинается инициализация класса Beetle // Инициализируется суперкласс Insect // Вызывается инициализатор для Insect.x1 static Insect.x1 initialized // Вызывается инициализатор для Beetle.x2 static Beetle.x2 initialized // Класс Beetle инициализирован, выполняется Beetle.main // выполняется print Beetle constructor // начинается создание экземпляра конструктором Beetle() // вызов this(..) в первой строке конструктора отсутствует (Beetle. шаг 2) // . будет вызван super() (Beetle. шаг 3) т.е. Insect() // внутри Insect() аналогично вызван Object() (Insect. шаг 3) // выполнение инициализации полей (Insect. шаг4) в порядке // . появления в тексте // i = 9; (поле i) // продолжаем выполнение конструктора Insect() (Insect. шаг 5) // Вывод полей в конструкторе: j инициализирован // . значением по-умолчанию на этапе выделения памяти i = 9, j = 0 // j = 39 // тело конструктора Insect() выполнено без ошибок // возвращаемя в Beetle(), переходим к инициализации полей (Beetle. шаг 4) // k = printInit("Beetle.k initialized") Beetle.k initialized // продолжаем выполнение конструктора Beetle() (Beetle. шаг 5) k = 47 j = 39 // тело конструктора Beetle() выполнено без ошибок

      So "Beetle constructor" is not displayed in the constructor itself, but before the constructor is called (in the main method).

      Those. you first output the "Beetle constructor" , then the "Beetle constructor" is called in which not the static variables are initialized first (because the static fields and blocks have already been initialized), and then the object itself is returned.

      I advise you to read the initialization fields

      • one
        I don’t understand why in the Incest class the initialization of class variables occurs before the constructor is called, and in the Beetle class, the constructor worked earlier than the initialization of the variable k. - Nara
      • 2
        "in the Beetle class, the constructor worked earlier than the initialization of the variable k" - you are mistaken. (Incest! = Insect) - Igor
      • What makes you think that the constructor worked before initializing the variable k? See where you get the output of the "Beetle constructor". You have this line called NOT in the constructor, and before it - Andrew Bystrov
      • The constructor of the class Insect worked earlier, but as far as I understand, its call comes from the constructor of the successor, namely Beetle, then the constructor of Beetle worked earlier (its implicit super () field). - Nara