Prefacio
En Java, un objeto debe inicializarse correctamente antes de que pueda usarse, lo que está estipulado por la especificación de Java.
Inicialización automática (predeterminado)
Se inicializarán todos los miembros de datos básicos de una clase. Ejecute el siguiente ejemplo para ver estos valores predeterminados:
clase predeterminada {boolean t; char c; byte b; bermudas; int i; largo L; flotante f; doble d; public void show() { System.out.println("Basic type initialization value/n"+ "boolean<----->" + t +"/n" + "char<------>" + c +"/n" + "byte<------->" + b + "/n" + "short<------>" + s + "/n" + "int<------>" + i + "/n" + "long<------>" + l + "/n" + "float <------>" + f + "/n" + "doble <----->" + d + "/n"); }} public class initValue {public static void main (string [] args) {default d = new Default (); d.show (); }}【Resultados de la operación】:
Valor de inicialización de tipo básico
booleano <-----> falso
char <----->
byte <-----> 0
corto <-----> 0
int <-----> 0
largo <-----> 0
flotante <-----> 0.0
Doble <-----> 0.0
Dónde, el valor predeterminado del tipo de char es nulo.
Para los tipos de datos no ejercicios, el mango del objeto también se inicializa:
Persona de clase {nombre de cadena privada; // setter} clase predeterminada {persona p; public void show () {system.out.println ("persona <--->" + p); }} public class initValue {public static void main (string [] args) {default d = new Default (); d.show (); }}【Resultados de la operación】:
Persona <-----> NULL
Se puede ver que el valor de inicialización del mango es nulo. Esto significa que si se llama a un método similar a p.setName sin especificar un valor de inicialización para P, se producirá una excepción.
Inicialización de las regulaciones
Si necesita asignar un valor inicial a una variable usted mismo, puede asignar un valor al definir la variable.
clase predeterminada {boolean t = true; char c = 'a'; byte b = 47; corto s = 0xff; int i = 24; largo L = 999; flotante f = 1.2f; doble d = 1.732; public void show () {System.out.println ("boolean <-ille>" + t + "/n" + "char <------>" + c + "/n" + "byte <------>" + b + "/n" + "corto <------>" + s + "/n" + "int <------>" + I + "/n" + "largo <----->" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + n "/n"/n "/n"/n "/n"/n "/n"/n " "float <------>>" + f + "/n" + "doble <------>" + d + "/n"); }} public class initValue {public static void main (string [] args) {default d = new Default (); d.show (); }}Incluso se puede inicializar de una manera;
Persona de clase {int i = set (); // ...}Estos métodos también pueden usar variables independientes:
persona de clase {int i; int j = set (i); // ...} Inicialización del constructor
La ventaja de inicializar un constructor es que el valor de inicialización se puede determinar durante el tiempo de ejecución. Por ejemplo:
Persona de clase {int Age; Persona () {edad = 89; }}La edad primero se inicializará a 0 y luego se convertirá en 89. Esto es cierto para todos los tipos básicos, así como los manijas de los objetos.
Orden de inicialización
En una clase, el orden de inicialización está determinado por el orden en el que las variables se definen dentro de la clase. Incluso si las definiciones variables se extienden en gran medida en el medio de la definición del método, la variable aún se inicializará antes de llamar a cualquier método (incluido el constructor). Por ejemplo:
Clase Pet {Pet (int Age) {System.out.println ("Pet (" + Age + ")"); }} Persona de clase {PET T1 = nueva PET (1); Persona () {System.out.println ("--- Person () ---"); t3 = nueva mascota (33); } PET T2 = nueva PET (2); void show () {system.out.println ("show ----- ejecutando"); } PET t3 = new Pet (3);} Orden de clase pública de la clase de delicinicialización {public static void main (string [] args) {persona p = nueva persona (); P.show (); }}【Resultados de la operación】:
Mascota (1)
Mascota (2)
Mascota (3)
--Persona()---
Mascota (33) <br/>
Show ----- Running
En el ejemplo anterior, aunque las definiciones de T1, T2 y T3 están en toda la clase, el orden de inicialización está determinado por el orden de definición de T1, T2 y T3 (cambie T1, T2 y T3 por usted mismo para ver el resultado), y la inicialización tiene prioridad sobre la ejecución del constructor. Cuando se llama al constructor de personas, T3 se reinicializa.
Inicialización de datos estáticos
Si los datos son estáticos, se realizará el mismo proceso. Si es un tipo primitivo y no se inicializa, obtendrá automáticamente su propio valor inicial de tipo primitivo estándar; Si es un mango de un objeto, obtendrá un valor nulo a menos que se cree un objeto y se conecte a él. Si se inicializa en el momento de la definición, el método tomado es diferente del valor no estático, porque la estática solo tiene un área de almacenamiento. Por ejemplo:
Class Bowl {Bowl (int Marker) {System.out.println ("Bowl (" + Marker + ")"); } void f (int marcador) {System.out.println ("f (" + marcador + ")"); }} tabla de clases {tazón estático B1 = nuevo tazón (1); Table () {System.out.println ("table ()"); b2.f (1); } void f2 (int marker) {system.out.println ("f2 (" + marcador + ")"); } tazón estático b2 = tazón nuevo (2);} armario de clase {tazón b3 = nuevo tazón (3); Tazón estático B4 = nuevo tazón (4); Armario () {System.out.println ("COPABLE ()"); b4.f (2); } void f3 (int marker) {system.out.println ("f3 (" + marcador + ")"); } tazón estático b5 = nuevo tazón (5);} clase pública staticinitialization {public static void main (string [] args) {system.out.println ("creando nuevo armario () en main"); nuevo armario (); System.out.println ("Creación de nuevo armario () en main"); nuevo armario (); T2.F2 (1); t3.f3 (1); } tabla estática t2 = nueva tabla (); armario estático t3 = nuevo armario ();}【Resultados de la operación】:
Tazón (1)
Tazón (2)
Mesa()
F (1)
Tazón (4)
Tazón (5)
Tazón (3)
Armario()
F (2)
Creando un nuevo armario () en main
Tazón (3)
Armario()
F (2)
Creando un nuevo armario () en main
Tazón (3)
Armario()
F (2)
F2 (1)
F3 (1)
Bloques de código estático
Java permite que otro trabajo de inicialización estática se divide en un bloque de código especial en la clase. Este bloque de código tiene la forma de una palabra clave estática seguida de un cuerpo de método, llamado bloque de código estático. Un bloque de código estático se ejecuta solo cuando el objeto de esa clase se genera por primera vez o se accede al miembro estático que pertenece a esa clase por primera vez. Por ejemplo:
Persona de clase {Person (int Age) {System.out.println ("Persona (" + Age + ")"); } void f (int age) {System.out.println ("f (" + edad + ")"); }} personas de clase {persona estática P1; persona estática P2; estática {p1 = nueva persona (1); P2 = nueva persona (2); } Personas () {system.out.println ("personas ()"); }} clase pública ExplicitStatic {public static void main (string [] args) {System.out.println ("Inside Main ()"); Personas.p1.f (18); // 1} Personas estáticas x = nuevas personas (); // 2 personas estáticas y = nuevas personas (); // 2}Al acceder al objeto estático P1 en una línea marcada 1, o si se comenta la línea 1 y la línea 2 no se comenta, el módulo de inicialización estática para las personas se ejecutará. Si se comentan tanto 1 como 2, no se ejecutará el bloque de código estático utilizado para las personas.
El orden de las propiedades estáticas y la ejecución del bloque de código estático
Persona de clase {Person (int Age) {System.out.println ("Persona ("+Age+")"); }} personas de clase {persona estática P = nueva persona (2); // 1 estática {p = nueva persona (3); } persona estática P = nueva persona (2); // 2} clase pública CompStaticInit {public static void main (string [] args) {} personas estáticas x = new Persons ();}De acuerdo con el análisis de los resultados de la anotación 1 retenida 2 y la anotación 2 retenida 1, se puede ver que el orden de ejecución de propiedades estáticas y bloques de código estático depende del orden de codificación. Quien esté por delante será ejecutado primero.
Inicialización de propiedades no estáticas
clase animal {animal (int a age) {System.out.println ("animal (" + edad + ")"); } void f (int age) {System.out.println ("f (" + edad + ")"); }} clase pública NotstaticInit {Animal A1; Animal A2; {a1 = nuevo animal (1); A2 = nuevo animal (2); System.out.println ("A1 y A2 inicializado"); } NotStaticInit () {System.out.println ("NotStaticInit"); } public static void main (string [] args) {System.out.println ("Inside Main ()"); NotstaticInit x = new NotStaticInit (); }}Similar a los bloques de código estático, la orden de inicialización de los bloques de código anónimo con propiedades no estáticas depende de la orden de codificación .
Proceso de inicialización de objetos heredado
insecto de clase {int i = 1; int j; Insect () {prt ("i =" + i + ", j =" + j); j = 2; } static int x1 = prt ("insecto estático.x1 inicializado"); static int prt (string s) {system.out.println (s); regresar 3; }} public class Beetle extiende insecto {int k = prt ("beeklt.k inicializado"); Beetle () {prt ("k =" + k); prt ("j =" + j); } static int x2 = prt ("static bootle.x2 inicializado"); static int prt (string s) {system.out.println (s); regresar 4; } public static void main (string [] args) {prt ("constructor de escarabajos"); Beetle B = nuevo Beetle (); }}【Resultados de la operación】:
insecto estático.x1 inicializado
static bootle.x2 inicializado
Constructor de escarabajos
i = 1, j = 0
Beeklt.k inicializado
k = 4
J = 2
Lo primero que sucede al ejecutar Java en Beetle es el cargador para encontrar esa clase afuera. Durante el proceso de carga, el cargador descubre una clase básica, por lo que se carga en consecuencia. Este proceso se realizará independientemente de si el objeto de la clase subyacente se genera o no. Si la clase base contiene otra clase base, la otra clase base se cargará, y así sucesivamente. A continuación, realice la inicialización estática en la clase base de raíz, luego ejecute en la siguiente clase de derivado, y así sucesivamente. Esto se debe a que la inicialización de la clase derivada puede depender de la inicialización de los miembros de la clase subyacente.
Cuando se cargan todas las clases, se pueden crear objetos. Primero, todos los tipos de datos básicos en este objeto se establecen en sus valores predeterminados y el mango del objeto se establece en NULL. Luego ejecute el constructor de la clase base. Esta situación se realiza automáticamente ( super()， y el constructor de la clase base también se puede especificar a través de Super). Después de completar el constructor de clase base, las variables de instancia de clase derivadas se inicializarán en su orden original, y las partes del cuerpo restantes del constructor se ejecutarán.
Resumir el proceso de creación de objetos:
La ejecución estática solo se realiza cuando la clase se carga y solo una vez;
No Static solo se ejecuta cuando se instancia y se ejecuta cada vez que se crea un objeto;
La ejecución estática se realiza antes de la clase no estática, y la clase base estática precede a la ejecución estática sobre las clases de derivados;
Las propiedades de ejecución de las propiedades estáticas y los bloques de código estático dependen de su posición en la clase, y quién las ejecuta primero;
La orden de ejecución de las propiedades y los bloques de constructor no estáticos depende de su posición en la clase y de quién se ejecuta ante ellos.
Resumir
A través de la introducción anterior, comprendemos varias formas de inicializar los objetos en Java y cómo ejecutar el código de inicialización, y también introduce las situaciones que podemos usar variables no inicializadas. Después de obtener una comprensión detallada de estos problemas, puede evitar algunos riesgos en la codificación para asegurarse de que un objeto se inicialice por completo antes de que se visible.