Aprendí que el principio para el orden de inicialización es:
Pero todavía estoy confundido por la salida de este código:
public class Test1 { static { add(2); } static void add (int num) { System.out.println(num + " "); } public Test1() { add(5); System.out.println("Constructor!"); } static { add(4); } { add(6); } static { new Test1(); } { add(8); } public static void main(String[] args) { System.out.println("Main method!"); add(10); } { add(11); } static { add(12); } }El resultado es:
2 4 6 8 11 5 Constructor! 12 Main method! 10Si sin las sentencias de add(10); sumar(11); sumar(12); Puedo entender totalmente. ¿Puede explicar el orden de inicialización de esas 3 declaraciones?
El inicializador estático es el primero, por lo que obtienes
2 4Pero en el siguiente inicializador estático, llama a una nueva instancia de Test1.class, por lo que se activan los inicializadores de instancia, el constructor se activa después de ellos y obtiene:
6 8 11 5 Constructor!Después de eso, se llama al resto de inicializadores estáticos. asi que:
12Y el último es el método principal:
Main method! 101) El bloque que no tiene un nombre como el que se muestra a continuación se llama " Inicializador de instancia ", que solo se llama cuando se crean nuevos objetos, como DefaultConstructor o noArg Constructor.
{ add(11); }2) En el código anterior, tiene un bloque estático ( que se llama primero en la carga de la clase ), el inicializador de instancia ( que se llama al crear el objeto ), el constructor predeterminado explícito ( que se llama al crear el objeto, pero recuerde siempre El inicializador de instancia tiene prioridad ) y el último método principal.
3) Ahora analicemos tu código,
1ra llamada:
static { add(2); //print 2 }2ª llamada:
static { add(4); // print 4 }3ra llamada:
static { new Test1(); // Here Object is getting created so all Instance Initialzer will be called first in a sequential manner. }4ª llamada:
{ add(6); // print 6 }5ª llamada:
{ add(8); // print 8 }6ª convocatoria:
{ add(11); // print 11 }Séptima llamada: después del inicializador de instancia, se llamará al constructor predeterminado explícito.
public Test1() { add(5); // print 5 System.out.println("Constructor!"); // print Constructor! }8ª llamada: Nuevamente se llamará al último bloque estático.
static { add(12); // print 12 }9ª llamada: Finalmente se llamará al método principal
public static void main(String[] args) { System.out.println("Main method!"); // print Main method! add(10); // print 10 }Creo que te confundiste porque (12) antes (método principal - 10)
Eso sucede porque el método principal se llama al final, pero el otro orden de inicialización está claro