Qual a diferença entre
Classe classe = null; e
Classe classe; quando você faz
Classe classe;
você está criando um tipo da classe Classe;
agora quando você coloca Classe classe=null;
você inicializa esse tipo como defalt
me desculpe se tiver enganado
abs
Quando vc cria:
Classe classe;Você cria um pontiero que não está apotando para lugar nenhum, tanto que se vc tentar usa-la sem atribuia-la a nada, o seu programa naum compila dando o seguinte erro: “The variable ‘classe’ might not be initialized”.
Agora quando vc declara:
Classe classe = null;Você cria um ponteiro apontando para um objeto nulo, ou seja ele foi inicializada, memso que esteja nula.
Nesse clima de achismo… vai minha opinião pessoal
Quando você faz…
Classe class;
if (class == null){
println("é nulo);
}
//...
try{
class.fazQualquerCoisa(comVasco);
}Geralmente os IDE’s reclaman dizendo que tal variavel não foi inicializada…
Classe class = null;
if (class == null){
println("é nulo);
}
//...
try{
class.fazQualquerCoisa(comVasco);
}Pra mim a única diferença é que “você inicializou ela explicitamente” logo a culpa é sua… se atribuiu null ou uma instancia…
Vamos deixar de achismo.
Existe uma diferença entre variáveis de instância e variáveis locais.
Variáveis de instância são inicializadas com null, 0 ou false se isso não for feito no construtor.
Variáveis locais devem ser explicitamente inicializadas se você vai usar seu valor antes de atribuir alguma coisa a elas.
É que o compilador consegue checar se você está usando a variável local antes de definir algum valor a ela, e reclama se isso for o caso.
Para não dar nenhum nó na cabeça vamos usar nomes adequados.
class Teste {
Classe varInstancia;
Teste () {
System.out.println (varInstancia); // quando este construtor for invocado, deve imprimir "null"
}
public static void main(String[] args) {
Classe varLocal; // aqui o valor está indefinido, portanto a linha seguinte nem vai compilar:
System.out.println (varLocal); // aqui dá um erro de compilação.
Classe2 varLocal2 = null; // aqui o valor foi definido
System.out.println (varLocal2); // sem erros de compilação
Classe3 varLocal3; // por enquanto o valor está indefinido...
varLocal3 = new Classe3(); // OK! você está atribuindo um valor antes de usar
System.out.println (varLocal3); // e portanto isto vai funcionar direitinho.
}
}Um vício que as pessoas têm é o de inicializar variáveis locais sem necessidade, só porque alguma vez na vida encontraram o tal erro de compilação e, para fazê-lo sumir, põem null ou 0 à toa.
m vez disso, considere que esse erro é um aviso de que você está se esquecendo de alguma coisa.
Pode ser, por exemplo, que você estivesse se esquecendo de criar uma nova instância…
veja este código:
public class Variables {
Classe classeInstancia; //ok sem erro
public static void main(String[] args) {
Classe klassLocal; //ok sem erro, mas o compilador espera que vc inicialize antes de usar a variável
klassLocal.imprime(); //erro: The local variable klassLocal may not have been initialized
}
}e agora:
public class Variables {
Classe classeInstancia; //ok sem erro
public static void main(String[] args) {
Classe klassLocal; //ok sem erro, mas o compilador espera que vc inicialize antes de usar a variável
klassLocal = new Classe();
klassLocal.imprime(); //ok, sem erro, klassLocal foi inicializada antes de ser usada.
}
}isso compila normalmente:
public class Variables {
Classe classeInstancia; //ok sem erro
public static void main(String[] args) {
Classe klassLocal;
}
}isso não:
public class Variables {
Classe classeInstancia; //ok sem erro
public static void main(String[] args) {
Classe klassLocal; //ok sem erro, mas o compilador espera que vc inicialize antes de usar a variável
System.out.println(klassLocal); //nããããoooo!
}
}DESAFIO!
Segundo a documentação java, uma variável de uma instância quando não inicializada explicitamente, é inicializada com null…
Quero ver alguém explicar então o seguinte código:
package teste;
public abstract class Pai {
public Pai() {
metodoAbstrato("Pai");
}
//mensagem que será impressa.
public abstract void metodoAbstrato(String mensagem);
}[code]
package teste;
public class Filho extends Pai {
/*
* Variável que esta apresentando problema
*
* private String texto; Assim imprime o texto definido pela super classe
* private String texto = null; Assim a variável é redeclarada e imprime o texto
* da classe filho
*/
private String texto;
public Filho() {
super();
metodoAbstrato("Filho");
System.out.println(texto);
}
//mensagem que será escrita
public void metodoAbstrato(String mensagem) {
if (texto == null) {
texto = mensagem;
}
}
/**
* Main
* @param args
*/
public static void main(String args[]) {
new Filho();
}
}[/code]
Como descrito no comentário da classe filho, quando inicializada explicitamente a variável TEXTO a saída é diferente de quando não é!
Confesso, que nunca tive curiosidade pra ir a fundo nesses detalhes de inicialização de objetos.
Esse artigo aqui me esclareceu o que acontece: http://www.artima.com/designtechniques/initializationP.html
Mais especificamente o trecho:
[quote]
When you instantiate a new Coffee object with the new operator, the Java virtual machine first will allocate (at least) enough space on the heap to hold all the instance variables declared in Coffee and its superclasses. Second, the virtual machine will initialize all the instance variables to their default initial values. Third, the virtual machine will invoke the <init> method in the Coffee class. [/quote]
Ou seja… texto é preenchido com null “antes” da execução de qualquer construtor…
Quando coloca um inicializador ( = null ), esta chamada é colocada após a invocação do super()… isso acaba devolvendo seu texto para null…
Daí quando é chamado o método abstrato no filho, o valor de texto já está como nulo novamente…
boa dica!