Pourquoi cela ne lance-t-il pas une NullPointerException?

Nead clarification pour le code suivant:

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

Cela s'imprimera de Bsorte que les preuves sampleet les referToSampleobjets se réfèrent à la même référence mémoire.

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

Cela imprimera ABqui prouve également la même chose.

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

Évidemment, cela jettera NullPointerExceptionparce que j'essaye d'appeler appendune référence nulle.

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

Donc, voici ma question, pourquoi le dernier exemple de code ne lance-t-il pas NullPointerExceptionparce que ce que je vois et comprends à partir des deux premiers exemples, c'est si deux objets faisant référence au même objet, si nous modifions une valeur, il reflétera également l'autre car les deux pointent vers même référence mémoire. Alors pourquoi cette règle ne s'applique-t-elle pas ici? Si nullj'assigne à referToSample, sample doit également être null et il doit lancer une NullPointerException mais il n'en lance pas une, pourquoi?

nullles affectations ne changent pas de valeur en détruisant globalement cet objet. Ce type de comportement conduirait à des bogues difficiles à suivre et à un comportement contre-intuitif. Ils ne cassent que cette référence spécifique .

Pour simplifier, disons que cela samplepointe vers l'adresse 12345. Ce n'est probablement pas l'adresse, et n'est utilisé que pour simplifier les choses ici. L'adresse est généralement représentée avec l'étrange hexadécimal donné dans Object#hashCode(), mais cela dépend de l'implémentation. ¹

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

À partir des lignes marquées, See diagramles schémas des objets à ce moment-là sont les suivants:

Diagramme 1:

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

Schéma 2:

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

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

Le diagramme 2 montre que l'annulation referToSamplene rompt pas la référence de sampleà StringBuilder at 00012345.

_{¹ Les considérations du CG rendent cela invraisemblable.}

Initialement , il était comme vous avez dit referToSamplese référait à samplecomme indiqué ci - dessous:

1. Scénario1:

2. Scénario1 (suite):

• Ici comme cela referToSamplefaisait référence sample, donc il a ajouté "B" pendant que vous écrivez

  referToSample.append("B")

La même chose s'est produite dans le scénario 2:

Mais, dans 3. Scénario3: comme l'a dit l'hexafraction,

lorsque vous attribuez nullà referToSamplequand il faisait référence , sampleil n'a pas changé la valeur au lieu de cela casse juste la référence de sample, et il fait maintenant nulle part . comme indiqué ci-dessous:

Maintenant, comme ne referToSamplepointe nulle part , alors que vous, referToSample.append("A");il n'aurait aucune valeur ou référence où il peut ajouter A. Donc, il lancerait NullPointerException.

MAIS sampleest toujours le même que vous l'aviez initialisé avec

StringBuilder sample = new StringBuilder(); donc il a été initialisé, donc maintenant il peut ajouter A, et ne lancera pas NullPointerException

En un mot: vous affectez null à une variable de référence, pas à un objet.

Dans un exemple, vous modifiez l' état d'un objet auquel se réfèrent deux variables de référence. Lorsque cela se produit, les deux variables de référence refléteront le changement.

Dans un autre exemple, vous modifiez la référence affectée à une variable, mais cela n'a aucun effet sur l'objet lui-même, et ainsi la deuxième variable, qui fait toujours référence à l'objet d'origine, ne remarquera aucun changement d'état de l'objet.

En ce qui concerne vos "règles" spécifiques:

si deux objets font référence au même objet, alors si nous modifions une valeur, cela se reflétera également sur l'autre car les deux pointent vers la même référence de mémoire.

Encore une fois, vous faites référence à la modification de l' état du seul objet auquel les deux variables font référence.

Alors pourquoi cette règle ne s'applique-t-elle pas ici? Si j'attribue null à referToSample, sample doit également être nul et lancer une exception nullPointerException mais il ne lance pas, pourquoi?

Encore une fois, vous modifiez la référence d'une variable qui n'a absolument aucun effet sur la référence de l'autre variable.

Ce sont deux actions complètement différentes et aboutiront à deux résultats complètement différents.

Voir ce schéma simple:

Lorsque vous appelez une méthode sur referToSample, puis [your object]est mis à jour, il affecte sampleaussi. Mais quand vous dites referToSample = null, vous changez simplement de quoi il referToSample s'agit .

Ici, «sample» et «referToSample» font référence au même objet. C'est le concept de pointeur différent accédant au même emplacement mémoire. Ainsi, affecter une variable de référence à null ne détruit pas l'objet.

   referToSample = null;

signifie 'referToSample' ne pointant que sur null, l'objet reste le même et les autres variables de référence fonctionnent correctement. Donc pour 'sample' qui ne pointe pas sur null et qui a un objet valide

   sample.append("A");

fonctionne très bien. Mais si nous essayons d'ajouter null à 'referToSample', cela affichera NullPointException. C'est,

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

C'est pourquoi vous avez NullPointerException dans votre troisième extrait de code.

Chaque fois qu'un nouveau mot-clé est utilisé, il crée un objet au niveau du tas

1) exemple StringBuilder = nouveau StringBuilder ();

2) StringBuilder referToSample = exemple;

En 2) la référence de referSample est créée sur le même objet échantillon

donc referToSample = null; Nulling Seule la référence referSample ne donne aucun effet à l'échantillon, c'est pourquoi vous n'obtenez pas d'exception de pointeur NULL grâce à la récupération de place de Java

Simplement facile, Java n'a pas de passe par référence, il passe simplement la référence d'objet.