java - traducir - ¿Por qué no está lanzando una NullPointerException?

nullpointerexception java try catch

Question

Una aclaración para el siguiente código:

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

Esto imprimirá B para que los objetos de sample y de referencia a sample referToSample referencia 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á AB que también prueba lo mismo.

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

Obviamente, esto arrojará NullPointerException porque estoy intentando llamar a append en una referencia nula.

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

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

Answer 1

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

   referToSample = null;

significa que ''referToSample'' solo apunta a nulo, el objeto permanece igual y otras variables de referencia funcionan bien. Entonces para ''sample'' que no apunta a nulo y tiene un objeto válido

   sample.append("A");

funciona bien. Pero si tratamos de agregar null a ''referToSample'', mostrará NullPointException. Es decir,

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

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

Answer 2

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

1) StringBuilder sample = 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 Sólo la Referencia de referencia de muestra no da ningún efecto a la muestra, es por eso que no se obtiene la Excepción de puntero NULL gracias a la Colección de basura de Java

Answer 3

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

En un ejemplo, cambia 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 todavía 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 algún valor, también se reflejará en otro porque ambos apuntan a la misma referencia de memoria.

Nuevamente, se refiere a cambiar el estado del único objeto al que se refieren ambas variables .

Entonces, ¿por qué esa regla no se aplica aquí? Si asigno null a referToSample, la muestra también debe ser nula y debe arrojar nullPointerException pero no está arrojando, ¿por qué?

De nuevo, cambia la referencia de una variable que no tiene ningún efecto en la referencia de la otra variable.

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

Answer 4

Inicialmente fue como usted dijo que referToSample se refería a la sample como se muestra a continuación:

1. Escenario1:

2. Escenario1 (cont.):

• Aquí, como referToSample se refería a la sample , por lo que se agregó "B" mientras escribes

  referToSample.append("B")

Lo mismo sucedió en Scenario2:

Pero, en 3. Escenario 3: como dijo hexafraction,

cuando asigna null a referToSample cuando se refería a la sample , no cambiaba el valor en su lugar, solo rompe la referencia de la sample , y ahora no apunta a ninguna parte . Como se muestra abajo:

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

PERO la sample sigue siendo la misma que la había inicializado con

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

Answer 5

Simplemente fácil, Java no tiene pase por referencia, simplemente pasa la referencia del objeto.

Answer 6

Vea este diagrama simple:

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

Answer 7

null asignaciones null no cambian el valor destruyendo globalmente ese objeto. Ese tipo de comportamiento daría lugar a errores difíciles de seguir y al comportamiento contrario a la intuición. Solo rompen esa referencia específica.

Para simplificar, digamos que la sample apunta a la dirección 12345. Probablemente esta no sea la dirección, y solo se usa para simplificar las cosas aquí. La dirección se representa típicamente con el extraño hexadecimal dado en 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 de referToSample no referToSample la referencia de la sample en StringBuilder en 00012345 .

_{¹ consideraciones GC lo hacen inverosímil.}