Orden de inicialización de variables estáticas
1. Reglas simples
Primero, veamos el código Java más común:
prueba de clase pública {public static test1 t = new test1 (); Público estático int a = 0; Pública estática int B; public static void main (string [] arg) {system.out.println (test.a); System.out.println (test.b); }} class test1 {public test1 () {test.a ++; Test.b ++; }}¿Aquí hay una suposición cuál es el resultado de salida de la consola?
Ok, tal vez haya adivinado el resultado a continuación, por lo que todavía está familiarizado con Java.
Copie el código de la siguiente manera: 0 1
Si no entiende por qué se emite el resultado anterior, entonces te lo diré.
La inicialización de la variable estática Java sigue las siguientes reglas:
Después de leer esto, comprenderá que el valor de la prueba. A ha cambiado tres veces.
Establecer en 0 cuando se declara >> test1 :: test1 se establece en 1 >> test.A se inicializa a 0
2. Reglas complejas
Si comprende esto, mire el código a continuación.
clase pública A {public static int b = ba; Public static a plus = new a ("a"); public static final int finalint = (int) (math.random ()*100); Pública estática B P = nueva B ("A"); Public static final String FinalStr = "FinalStr"; Public static final entero finalinteger = nuevo entero (10); Público estático int a = 1; Pública estática B C = NULL; public a (String from) {System.out.println ("----------- Comenzar a :: a ----------------"); System.out.println ("a :: a, from ="+from); System.out.println ("a :: a, ab ="+ab); System.out.println ("A :: A, A.FinalInt ="+A.FinalInt); System.out.println ("a :: a, ba ="+ba); System.out.println ("a :: a, b.plus ="+b.plus); System.out.println ("----------- End a :: a ----------------"); } public static void main (string [] arg) {system.out.println ("main, ab ="+ab); System.out.println ("main, bt ="+bt); System.out.println ("Main, Ca ="+Ca); }} clase B {public static int t = aa; Public static a plus = new a ("b"); Público estático int a = 1; public B (String from) {System.out.println ("----------- BEGIN B :: B -----------------------"); System.out.println ("b :: b, from ="+from); System.out.println ("b :: b, ba ="+ba); System.out.println ("b :: b, aa ="+aa); System.out.println ("b :: b, ap ="+ap); System.out.println ("B :: B, A.Plus ="+A.Plus); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInt ="+A.FinalInt); System.out.println ("B :: B, A.FinalInteger ="+A.FinalInteger); System.out.println ("B :: B, A.FinalStr ="+A.FinalStr); System.out.println ("----------- End b :: b ----------------"); }} Clase C {public static final A a a = new a ("c");}¿Todavía puedes adivinar el resultado de salida? Lo escribí mientras probaba, así que no lo suponía. Ja ja
El resultado de salida de la consola es:
--------- A.FinalInt = 0a :: a, ba = 1a :: a, b.plus=a@a90653---------- fin a :: a ----------------------------- Comienzo b :: b ---------------- B :: b, from = ab :: b, ba = 1b :: b, aa = 0b :: b, ap = nullb :: b, a.plus=a- A.FinalInt = 61b :: B, A.FinalInteger = nullb :: b, A.FinalStr = FinalStr --------------- End b :: b -------------------- Main, AB = 1Main, Bt = 0 --------- B.plus=a@a90653---------- Fin a :: A ------------------------ principal, CA = A@61de33
No adivinaste este resultado, jaja.
Se necesita mucho tiempo para explicar los resultados de ejecución del programa uno por uno. Aquí escribiremos directamente las reglas seguidas de la inicialización de la variable estática Java.
Las reglas en el primer párrafo siguen siendo válidas, pero no son sólidas.
Inicialización de datos estáticos
Agregar campos calificados estáticos es el llamado campo de clase, lo que significa que el propietario de este campo no es un objeto sino una clase. No importa cuántos objetos se creen, solo hay una copia de datos estáticos.
El campo estático siempre se inicializa en la clase y luego se inicializa el campo general. Luego inicialice el constructor. Sin embargo, si no se crea un objeto de esta clase, el objeto no se inicializará y solo se ejecutará una vez.
Como en el siguiente código, en la clase StaticInitialization, tabla estática Tabla = nueva tabla (); Primero, y luego el objeto de tabla no se inicializará, de lo contrario no se inicializará.
class bowl {towl (int marker) {print ("tazón (" + marcador + ")"); } void f1 (int marcador) {print ("f1 (" + marcador + ")"); }} tabla de clases {tazón estático1 = tazón nuevo (1); Table () {print ("table ()"); Bowl2.f1 (1); } void f2 (int marcador) {print ("f2 (" + marcador + ")"); } tazón estático2 = tazón nuevo (2);} armario de clase {tazón de tazón3 = nuevo tazón (3); tazón estático 4 = tazón nuevo (4); Armario () {print ("armario ()"); Bowl4.f1 (2); } void f3 (int marker) {print ("f3 (" + marcador + ")"); } static bowl bowl5 = new bowl (5);} clase pública staticinitialization {public static void main (string [] args) {imprime ("creando nuevo armario () en main"); nuevo armario (); imprimir ("Crear nuevo armario () en main"); nuevo armario (); table.f2 (1); armario.f3 (1); } tabla de tabla estática = nueva tabla (); armario de armario estático = nuevo armario ();}Producción:
Tazón (1) tazón (2) mesa () f1 (1) tazón (4) tazón (5) tazón (3) armario () f1 (2) Creación de armario nuevo () en mainbowl (3) armario () f1 (2) creando un nuevo armario () en mainbowl (3) armario () f1 (2) f2 (1) f3 (1)
La inicialización estática mostrada (es decir, bloques estáticos)
Poner múltiples declaraciones de inicialización en un aparato ortopédico se llama bloque estático. De hecho, se escribe juntos escribiendo múltiples estadísticas, y la esencia es la misma. Se ejecuta solo cuando el objeto se crea por primera vez o se accede al campo de la clase por primera vez, y solo una vez.
clase CUP {copa (int marcador) {print ("copa (" + marcador + ")"); } void f (int marcador) {print ("f (" + marcador + ")"); }} Clases de clase {copa estática Copa1; taza de taza estática2; estática {copa1 = nueva taza (1); CUP2 = nueva taza (2); } Tazas () {imprime ("tazas ()"); }} clase pública ExplicitStatic {public static void main (string [] args) {print ("dentro de main ()"); Tazs.cup1.f (99); // (1)} // tazas estáticas tazas1 = nuevas tazas (); // (2) // tazas estáticas tazas2 = nuevas tazas (); // (2)}Producción:
Inside Main () Copa (1) Copa (2) F (99)
Inicialización de instancias no estáticas
No hay nada que decir sobre esto, es solo una inicialización ordinaria, se ejecuta en orden y se puede ejecutar varias veces.
MUG de clase {Mug (int Marker) {print ("Mug (" + Marker + ")"); } void f (int marcador) {print ("f (" + marcador + ")"); }} Public Class Mugs {Mug Mug1; Taza taza2; {mug1 = nueva taza (1); Mug2 = nueva taza (2); imprimir ("Mug1 y Mug2 inicializado"); } Tazas () {print ("tazas ()"); } Tazas (int i) {print ("tazas (int)"); } public static void main (string [] args) {print ("dentro de main ()"); nuevas tazas (); imprimir ("nuevas tazas () completadas"); nuevas tazas (1); imprimir ("nuevas tazas (1) completadas"); }}Inside Main () Mug (1) Mug (2) Mug1 y Mug2 InicializedMugs () nuevas tazas () completadas (1) Mug (2) Mug1 y Mug2 Inicializadas Mugs (int) nuevas tazas (1) completado