Por que isso não está gerando um NullPointerException?

Esclarecimento Nead para o seguinte código:

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample.append("B");
System.out.println(sample);

Isso será impresso de Bforma que provas samplee referToSampleobjetos se refiram à mesma referência de memória.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
sample.append("A");
referToSample.append("B");
System.out.println(referToSample);

Isso vai imprimir ABque também prova o mesmo.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample = null;
referToSample.append("A");
System.out.println(sample);

Obviamente, isso vai lançar NullPointerExceptionporque estou tentando chamar appenduma referência nula.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample = null;
sample.append("A");
System.out.println(sample);

Então, aqui está minha pergunta, por que o último exemplo de código não está sendo lançado, NullPointerExceptionporque o que eu vejo e entendo nos dois primeiros exemplos é se dois objetos se referindo ao mesmo objeto, se alterarmos qualquer valor, ele também refletirá para outro porque ambos estão apontando para mesma referência de memória. Então, por que essa regra não se aplica aqui? Se eu atribuir nulla referToSample, sample também deve ser nulo e deve lançar um NullPointerException, mas não está jogando um, por quê?

nullatribuições não mudam o valor destruindo globalmente esse objeto. Esse tipo de comportamento levaria a bugs difíceis de rastrear e comportamento contra-intuitivo. Eles apenas quebram aquela referência específica .

Para simplificar, digamos que sampleaponta para o endereço 12345. Este provavelmente não é o endereço e é usado apenas para simplificar as coisas aqui. O endereço é normalmente representado com o hexadecimal estranho fornecido Object#hashCode(), mas isso depende da implementação. ¹

StringBuilder sample = new StringBuilder(); //sample refers to 
//StringBuilder at 12345 

StringBuilder referToSample = sample; //referToSample refers to 
//the same StringBuilder at 12345 
//SEE DIAGRAM 1

referToSample = null; //referToSample NOW refers to 00000, 
//so accessing it will throw a NPE. 
//The other reference is not affected.
//SEE DIAGRAM 2

sample.append("A"); //sample STILL refers to the same StringBuilder at 12345 
System.out.println(sample);

A partir das linhas marcadas, See diagramos diagramas dos objetos naquele momento são os seguintes:

Diagrama 1:

[StringBuilder sample]    -----------------> [java.lang.StringBuilder@00012345]
                                                      ↑
[StringBuilder referToSample] ------------------------/

Diagrama 2:

[StringBuilder sample]    -----------------> [java.lang.StringBuilder@00012345]

[StringBuilder referToSample] ---->> [null pointer]

O Diagrama 2 mostra que a anulação referToSamplenão quebra a referência de sampleao StringBuilder em 00012345.

_{^{1 As} considerações do GC tornam isso implausível.}

Inicialmente era como você disse que referToSamplese referia samplecomo mostrado abaixo:

1. Cenário 1:

2. Cenário 1 (cont.):

• Aqui, como referToSampleestava se referindo a sample, então ele anexou "B" enquanto você escreve

  referToSample.append("B")

A mesma coisa aconteceu no Cenário 2:

Mas, em 3. Cenário 3: como disse a hexafração,

quando você atribui nullpara referToSamplequando ele estava se referindo samplenão mudança de valor em vez disso, apenas quebra a referência a partir de sample, e agora ele aponta a lugar nenhum . como mostrado abaixo:

Agora, como nãoreferToSample aponta para lugar nenhum , embora você referToSample.append("A");não tenha nenhum valor ou referência onde possa anexar A. Então, ele jogaria NullPointerException.

MAS sampleainda é o mesmo que você inicializou com

StringBuilder sample = new StringBuilder(); então ele foi inicializado, então agora ele pode anexar A, e não vai lançar NullPointerException

Resumindo: você atribui null a uma variável de referência, não a um objeto.

Em um exemplo, você altera o estado de um objeto que é referido por duas variáveis ​​de referência. Quando isso ocorrer, ambas as variáveis ​​de referência refletirão a mudança.

Em outro exemplo, você altera a referência atribuída a uma variável, mas isso não tem efeito sobre o objeto em si e, portanto, a segunda variável, que ainda se refere ao objeto original, não notará qualquer alteração no estado do objeto.

Quanto às suas "regras" específicas:

se dois objetos se referirem ao mesmo objeto, se alterarmos qualquer valor, ele também refletirá para outro, porque ambos estão apontando para a mesma referência de memória.

Novamente, você se refere à alteração do estado de um objeto ao qual ambas as variáveis ​​se referem.

Então, por que essa regra não se aplica aqui? Se eu atribuir null a referToSample, sample também deve ser null e deve lançar nullPointerException, mas não está jogando, por quê?

Novamente, você altera a referência de uma variável que não tem absolutamente nenhum efeito na referência da outra variável.

Essas são duas ações completamente diferentes e resultarão em dois resultados completamente diferentes.

Veja este diagrama simples:

Quando você chama um método on referToSample, o [your object]é atualizado, por isso afeta sampletambém. Mas quando você diz referToSample = null, então você está simplesmente mudando o que referToSample se refere .

Aqui, 'sample' e 'referToSample' fazem referência ao mesmo objeto. Esse é o conceito de ponteiro diferente acessando o mesmo local de memória. Portanto, atribuir uma variável de referência a nulo não destrói o objeto.

   referToSample = null;

significa 'referToSample' apontando apenas para nulo, o objeto permanece o mesmo e outras variáveis ​​de referência estão funcionando bem. Portanto, para 'amostra' que não aponta para nulo e tem um objeto válido

   sample.append("A");

funciona bem. Mas se tentarmos acrescentar null a 'referToSample', ele mostrará NullPointException. Isso é,

   referToSample .append("A");-------> NullPointerException

É por isso que você obteve NullPointerException em seu terceiro trecho de código.

Sempre que uma nova palavra-chave é usada, ela cria um objeto no heap

1) Amostra StringBuilder = new StringBuilder ();

2) StringBuilder referToSample = amostra;

Em 2) a referência de referSample é criada na mesma amostra de objeto

portanto, referToSample = null; está anulando apenas a referência referSample, não dando efeito à amostra, por isso você não está recebendo a exceção de ponteiro NULL graças à coleta de lixo do Java

Simplesmente fácil, Java não tem passagem por referência, apenas passa referência de objeto.