¿Por qué esto no arroja una NullPointerException?

Nead aclaración para el siguiente código:

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

Esto se imprimirá Bpara que las pruebas sampley los referToSampleobjetos se refieran a la misma referencia de memoria.

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

Esto imprimirá ABque también prueba lo mismo.

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

Obviamente, esto arrojará NullPointerExceptionporque estoy tratando de llamar appenda una referencia nula.

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

Entonces, aquí está mi pregunta, ¿por qué la última muestra de código no arroja? NullPointerExceptionPorque lo que veo y entiendo de los primeros dos ejemplos es si dos objetos se refieren al mismo objeto, entonces, si cambiamos cualquier valor, también se reflejará en otro porque ambos apuntan a misma referencia de memoria. Entonces, ¿por qué esa regla no se aplica aquí? Si asigno nulla referToSample, la muestra también debería ser nula y debería arrojar una NullPointerException pero no arroja una, ¿por qué?

nulllas asignaciones no cambian el valor al destruir globalmente ese objeto. Ese tipo de comportamiento conduciría a errores difíciles de rastrear y comportamientos contrarios a la intuición. Solo rompen esa referencia específica .

Para simplificar, digamos que sampleapunta a la dirección 12345. Probablemente esta no sea la dirección, y solo se usa para simplificar las cosas aquí. La dirección generalmente se representa con el extraño hexadecimal dado Object#hashCode(), pero esto depende de la implementación. ¹

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);

De las líneas marcadas See diagram los diagramas de los objetos en ese momento son los siguientes:

Diagrama 1:

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

Diagrama 2:

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

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

El diagrama 2 muestra que la anulación referToSampleno rompe la referencia desample al StringBuilder en 00012345.

_{¹ consideraciones de GC hacen que esto sea inverosímil.}

Inicialmente fue como dijiste que referToSamplese refería a lo sampleque se muestra a continuación:

1. Escenario 1:

2. Escenario 1 (cont.):

• Aquí, como referToSamplese refería sample, se agregó "B" mientras escribe

  referToSample.append("B")

Lo mismo sucedió en el escenario 2:

Pero, en 3. Escenario 3: como dijo la hexafracción,

cuando se asigna nulla referToSamplecuando se refería sampleNo cambió el valor en vez de eso me rompe la referencia a sample, y ahora apunta a ninguna parte . Como se muestra abajo:

Ahora, como noreferToSample apunta a ninguna parte , mientras que usted referToSample.append("A");no tendría ningún valor o referencia donde pueda agregar A. Entonces, arrojaríaNullPointerException .

PERO samplesigue siendo el mismo que lo había inicializado con

StringBuilder sample = new StringBuilder(); por lo que se ha inicializado, por lo que ahora puede agregar A, y no arrojará NullPointerException

En pocas palabras: asigna nulo a una variable de referencia, no a un objeto.

En un ejemplo cambias el estado de un objeto al que hacen referencia dos variables de referencia. Cuando esto ocurre, ambas variables de referencia reflejarán el cambio.

En otro ejemplo, cambia la referencia asignada a una variable, pero esto no tiene ningún efecto en el objeto en sí, por lo que la segunda variable, que aún se refiere al objeto original, no notará ningún cambio en el estado del objeto.

En cuanto a sus "reglas" específicas:

si dos objetos se refieren al mismo objeto, si cambiamos cualquier valor, también se reflejará en otro porque ambos apuntan a la misma referencia de memoria.

Nuevamente, se refiere a cambiar el estado de un objeto al que se refieren ambas variables .

Entonces, ¿por qué esa regla no se aplica aquí? Si asigno nulo a referToSample, la muestra también debería ser nula y debería arrojar nullPointerException pero no arroja, ¿por qué?

Nuevamente, cambia la referencia de una variable que no tiene absolutamente ningún efecto sobre la referencia de la otra variable.

Estas son dos acciones completamente diferentes y darán como resultado dos resultados completamente diferentes.

Vea este diagrama simple:

Cuando se llama a un método en referToSample, a continuación, [your object]se actualiza, por lo que afecta sampletambién. Pero cuando dices referToSample = null, simplemente estás cambiando a qué se referToSample refiere .

Aquí 'muestra' y 'referToSample' hacen referencia al mismo objeto. Ese es el concepto de puntero diferente que accede a la misma ubicación de memoria. Entonces, asignar una variable de referencia a nulo no destruye el objeto.

   referToSample = null;

significa que 'referToSample' solo apunta a nulo, el objeto sigue siendo el mismo y otras variables de referencia funcionan bien. Entonces, para 'muestra' que no apunta a nulo y tiene un objeto válido

   sample.append("A");

funciona bien. Pero si intentamos agregar un valor nulo a 'referToSample', mostrará NullPointException. Es decir,

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

Es por eso que obtuvo NullPointerException en su tercer fragmento de código.

Siempre que se usa una nueva palabra clave, se crea un objeto en el montón

1) Ejemplo de StringBuilder = new StringBuilder ();

2) StringBuilder referToSample = muestra;

En 2) la referencia de referSample se crea en la misma muestra de objeto

por lo tanto, referToSample = null; está anulando solo la referencia referSample que no da ningún efecto a la muestra, por eso no obtiene la excepción de puntero NULL gracias a la recolección de basura de Java

Simplemente fácil, Java no tiene paso por referencia, solo pasa la referencia del objeto.