Prefácio
Em Java, um objeto deve ser inicializado corretamente antes de poder ser usado, que é estipulado pela especificação Java.
Inicialização automática (padrão)
Todos os membros básicos de dados de uma classe serão inicializados. Execute o exemplo a seguir para visualizar esses valores padrão:
classe padrão {boolean t; char c; byte b; shorts; int i; Long L; flutuar f; duplo d; public void show () {System.out.println ("Tipo básico Valor de inicialização/n" + "booleano <-----" + t + "/n" + "char <------>" + c + "/n" + " +"/------ "" + b + "/" + curto l + "/n" + "float <------>" + f + "/n" + "duplo <-----" + d + "/n"); }} classe pública initValue {public static void main (string [] args) {padrão d = new padrão (); d.show (); }}【Resultados da operação】:
Valor de inicialização do tipo básico
booleano <-----> false
Char <----->
byte <-----> 0
curto <-----> 0
int <-----> 0
longo <-----> 0
FLOAT <-----> 0.0
duplo <-----> 0.0
Onde, o valor padrão do tipo de char é nulo.
Para tipos de dados não primitivos, o identificador do objeto também é inicializado:
classe Pessoa {Nome da String Private; // setter} classe padrão {pessoa p; public void show () {System.out.println ("pessoa <---->" + p); }} classe pública initValue {public static void main (string [] args) {padrão d = new padrão (); d.show (); }}【Resultados da operação】:
Pessoa <----- NULL
Pode -se observar que o valor de inicialização do manipulação é nulo. Isso significa que, se um método semelhante ao p.setName for chamado sem especificar um valor de inicialização para P, ocorrerá uma exceção.
Inicialização dos regulamentos
Se você precisar atribuir um valor inicial a uma variável, poderá atribuir um valor ao definir a variável.
classe padrão {boolean t = true; char c = 'a'; byte b = 47; curto s = 0xff; int i = 24; longo l = 999; flutuar f = 1,2f; duplo d = 1,732; public void show () {System.out.println ("boolean <----->" + t + "/n" + "char <------>" + c + "/n" + "byte <---- "float <------>" + f + "/n" + "duplo <------>" + d + "/n"); }} classe pública initValue {public static void main (string [] args) {padrão d = new padrão (); d.show (); }}Pode até ser inicializado de uma maneira;
classe pessoa {int i = set (); // ...}Esses métodos também podem usar variáveis independentes:
classe Pessoa {int i; int j = set (i); // ...} Inicialização do construtor
A vantagem de inicializar um construtor é que o valor da inicialização pode ser determinado durante o tempo de execução. Por exemplo:
classe Pessoa {Int Age; Pessoa () {idade = 89; }}A idade será inicializada primeiro para 0 e depois se tornará 89. Isso é verdade para todos os tipos básicos, além de lidar com objetos.
Ordem de inicialização
Em uma classe, a ordem de inicialização é determinada pela ordem em que as variáveis são definidas dentro da classe. Mesmo que as definições variáveis sejam amplamente espalhadas pelo meio da definição do método, a variável ainda será inicializada antes de chamar qualquer método (incluindo o construtor). Por exemplo:
classe PET {PET (Int Age) {System.out.println ("PET (" + Age + ")"); }} classe Pessoa {pet t1 = novo PET (1); Pessoa () {System.out.println ("--- pessoa () ---"); t3 = novo animal de estimação (33); } PET T2 = novo PET (2); void show () {System.out.println ("show ----- Running"); } PET T3 = novo PET (3);} classe pública OrderOfinitialization {public static void main (string [] args) {pessoa p = new Person (); p.show (); }}【Resultados da operação】:
PET (1)
PET (2)
PET (3)
--Pessoa()---
PET (33) <br/>
MOSTRAR ----- RANDE
No exemplo acima, embora as definições de T1, T2 e T3 estejam por toda a classe, a ordem de inicialização é determinada pela ordem de definição de T1, T2 e T3 (altere T1, T2 e T3 por si mesmo para ver o resultado), e a inicialização tem precedência sobre a execução do construtor. Quando o construtor de pessoas é chamado, o T3 é reinicializado.
Inicialização de dados estáticos
Se os dados forem estáticos, o mesmo processo será executado. Se for um tipo primitivo e não for inicializado, ele obterá automaticamente seu próprio valor inicial do tipo primitivo padrão; Se for um identificador para um objeto, ele obterá um valor nulo, a menos que um objeto seja criado e conectado a ele. Se inicializado no horário da definição, o método tomado é diferente do valor não estático, porque estático possui apenas uma área de armazenamento. Por exemplo:
Classe Bowl {Bowl (int marker) {System.out.println ("Bowl (" + Marker + ")"); } void f (int marker) {System.out.println ("f (" + marker + ")); }} tabela de classe {tigela estática b1 = nova tigela (1); Tabela () {System.out.println ("tabela ()"); B2.f (1); } void f2 (int marker) {System.out.println ("f2 (" + marker + ")"); } tigela estática b2 = nova tigela (2);} armário de classe {tigela b3 = nova tigela (3); tigela estática b4 = nova tigela (4); Cupboard () {System.out.println ("cupboard ()"); B4.f (2); } void f3 (int marker) {System.out.println ("f3 (" + marker + ")"); } tigela estática b5 = nova tigela (5);} classe pública staticinitialization {public static void main (string [] args) {system.out.println ("criando new cupboard () em main"); novo armário (); System.out.println ("Criando new Cupboard () em Main"); novo armário (); t2.f2 (1); t3.f3 (1); } tabela estática t2 = new tabela (); armário estático t3 = novo armário ();}【Resultados da operação】:
Tigela (1)
Tigela (2)
Mesa()
f (1)
Tigela (4)
Tigela (5)
Tigela (3)
Armário()
f (2)
Criando novo armário () em principal
Tigela (3)
Armário()
f (2)
Criando novo armário () em principal
Tigela (3)
Armário()
f (2)
F2 (1)
F3 (1)
Blocos de código estático
O Java permite que outro trabalho de inicialização estática seja dividido em um bloco de código especial na classe. Este bloco de código está na forma de uma palavra -chave estática seguida por um corpo de método, chamado de bloco de código estático. Um bloco de código estático é executado apenas quando o objeto dessa classe é gerado pela primeira vez ou o membro estático pertencente a essa classe é acessado pela primeira vez. Por exemplo:
classe Pessoa {Pessoa (Int Age) {System.out.println ("Person (" + Age + ")"); } void f (int Age) {System.out.println ("f (" + idade + ")"); }} classe pessoas {pessoa estática p1; pessoa estática P2; estático {p1 = nova pessoa (1); p2 = nova pessoa (2); } Pessoas () {System.out.println ("pessoas ()"); }} classe pública explicitstatic {public static void main (string [] args) {System.out.println ("Inside main ()"); Pessoas.p1.f (18); // 1} pessoas estáticas x = novas pessoas (); // 2 pessoas estáticas y = novas pessoas (); // 2}Ao acessar o objeto estático P1 em uma linha marcada 1, ou se a linha 1 for comentada e a linha 2 não for comentada, o módulo de inicialização estática para pessoas será executado. Se 1 e 2 forem comentados, o bloco de código estático usado para pessoas não será executado.
A ordem das propriedades estáticas e execução do bloco de código estático
classe Pessoa {Pessoa (Int Age) {System.out.println ("Person ("+Age+")"); }} classe pessoas {pessoa estática p = nova pessoa (2); // 1 estático {p = nova pessoa (3); } pessoa estática p = nova pessoa (2); // 2} classe pública CompstaticInit {public static void main (string [] args) {} pessoas estáticas x = new Persons ();}De acordo com a análise dos resultados da anotação 1 retendo 2 e anotação 2 Retter 1, pode -se observar que a ordem de execução de propriedades estáticas e blocos de código estático depende da ordem da codificação. Quem estiver à frente será executado primeiro.
Inicialização de propriedades não estáticas
classe Animal {animal (Int Age) {System.out.println ("Animal (" + Age + ")"); } void f (int Age) {System.out.println ("f (" + idade + ")"); }} classe pública NotStaticInit {animal A1; Animal A2; {a1 = novo animal (1); A2 = novo animal (2); System.out.println ("A1 e A2 Inicializado"); } NotStaticInit () {System.out.println ("notstaticinit"); } public static void main (string [] args) {System.out.println ("Inside main ()"); Não estáticado x = new notstaticinit (); }}Semelhante aos blocos de código estático, a ordem de inicialização dos blocos de código anônimos com propriedades não estáticas depende da ordem de codificação .
Processo de inicialização de objetos herdados
classe inseto {int i = 1; int j; Inset () {prt ("i =" + i + ", j =" + j); j = 2; } estático int x1 = prt ("estático inset.x1 inicializado"); static int prt (strings) {System.out.println (s); retornar 3; }} classe pública Beetle estende o inseto {int k = prt ("beeklt.k inicializado"); Beetle () {prt ("k =" + k); prt ("j =" + j); } static int x2 = prt ("estático bootle.x2 inicializado"); static int prt (strings) {System.out.println (s); retornar 4; } public static void main (string [] args) {prt ("construtor de besouro"); Besouro b = new Beetle (); }}【Resultados da operação】:
estático inset.x1 inicializado
estático bootle.x2 inicializado
Construtor de besouro
i = 1, j = 0
Beeklt.k inicializado
k = 4
j = 2
A primeira coisa que acontece ao executar o Java no Beetle é o carregador para encontrar essa aula do lado de fora. Durante o processo de carregamento, o carregador descobre uma classe básica, por isso é carregado de acordo. Esse processo será realizado independentemente de o objeto da classe subjacente ser gerado ou não. Se a classe base contiver outra classe base, a outra classe base será carregada e assim por diante. Em seguida, execute a inicialização estática na classe Base Root e execute na próxima classe derivada e assim por diante. Isso ocorre porque a inicialização da classe derivada pode depender da inicialização dos membros da classe subjacente.
Quando todas as classes são carregadas, os objetos podem ser criados. Primeiro, todos os tipos de dados básicos nesse objeto são definidos como seus valores padrão e o identificador de objeto é definido como nulo. Em seguida, execute o construtor da classe base. Essa situação é feita automaticamente ( super()， e o construtor da classe base também pode ser especificado através do super). Depois que o construtor de classe base for concluído, as variáveis de instância de classe derivada serão inicializadas em sua ordem original e as partes do corpo restantes do construtor serão executadas.
Resuma o processo de criação de objetos:
A execução estática é realizada apenas quando a classe é carregada e apenas uma vez;
A não estática é executada apenas quando instanciada e executa toda vez que um objeto é criado;
A execução estática é realizada antes da execução estática não estática, e a classe estática precede a execução estática sobre classes derivadas;
As propriedades de execução das propriedades estáticas e dos blocos de código estático dependem de sua posição na classe e que os executa primeiro;
A ordem de execução de propriedades e blocos de construtor não estáticos depende de sua posição na classe e quem é executado diante deles.
Resumir
Através da introdução acima, temos uma compreensão de várias maneiras de inicializar objetos em Java e como executar o código de inicialização e também introduz as situações que podemos usar variáveis não inicializadas. Depois de obter uma compreensão detalhada desses problemas, você pode evitar alguns riscos na codificação para garantir que um objeto seja completamente inicializado antes de se tornar visível.