Почему при этом не генерируется исключение NullPointerException?

Необходимое разъяснение для следующего кода:

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

Это будет напечатано, Bчтобы доказательства sampleи referToSampleобъекты ссылались на одну и ту же ссылку в памяти.

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

Это напечатает, ABчто тоже доказывает то же самое.

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

Очевидно, это вызовет ошибку, NullPointerExceptionпотому что я пытаюсь вызвать appendнулевую ссылку.

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

Итак, вот мой вопрос, почему последний образец кода не бросается, NullPointerExceptionпотому что то, что я вижу и понимаю из первых двух примеров, - это если два объекта относятся к одному и тому же объекту, тогда, если мы изменим какое-либо значение, оно также отразится на другом, потому что оба указывают на та же ссылка на память. Так почему это правило здесь не применяется? Если я назначаю nullreferToSample, тогда образец также должен быть нулевым, и он должен генерировать исключение NullPointerException, но не выбрасывает его, почему?

nullназначения не изменяют значение , глобально уничтожая этот объект. Такое поведение привело бы к трудно отслеживаемым ошибкам и противоречивому поведению. Они нарушают только эту конкретную ссылку .

Для простоты предположим, что это sampleуказывает на адрес 12345. Вероятно, это не адрес, и он используется здесь только для упрощения работы. Адрес обычно представляется в странном шестнадцатеричном формате Object#hashCode(), но это зависит от реализации. ¹

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

Из отмеченных линий See diagramсхемы объектов на тот момент выглядят следующим образом:

Диаграмма 1:

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

Диаграмма 2:

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

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

На диаграмме 2 показано, что аннулирование referToSampleне нарушает ссылку sampleна StringBuilder в 00012345.

_{¹ Соображения GC делают это неправдоподобным.}

Первоначально, как вы сказали, referToSampleимелось в виду, sampleкак показано ниже:

1. Сценарий 1:

2. Сценарий 1 (продолжение):

• Здесь, как referToSampleимелось в виду sample, добавляется буква "B", пока вы пишете

  referToSample.append("B")

То же самое произошло в сценарии 2:

Но в 3. Сценарий 3: как сказано в гексафракции,

при назначении nullна , referToSampleкогда он имел в виду sampleего не изменить значение вместо этого он просто разрывает ссылку из sample, и теперь он не указывает нигде . как показано ниже:

Теперь, как referToSampleточки нигде , так что пока вы referToSample.append("A");это не будете иметь любые значения или ссылки , где он может приобщать А. Таким образом, было бы бросить NullPointerException.

НО sampleостается таким же, как и вы инициализировали его с помощью

StringBuilder sample = new StringBuilder(); поэтому он был инициализирован, поэтому теперь он может добавлять A и не будет бросать NullPointerException

В двух словах: вы присваиваете null ссылочной переменной, а не объекту.

В одном примере вы изменяете состояние объекта, на который ссылаются две ссылочные переменные. Когда это произойдет, обе ссылочные переменные будут отражать изменение.

В другом примере вы меняете ссылку, назначенную одной переменной, но это не влияет на сам объект, и поэтому вторая переменная, которая все еще ссылается на исходный объект, не заметит никаких изменений в состоянии объекта.

Итак, что касается ваших конкретных «правил»:

если два объекта относятся к одному и тому же объекту, тогда, если мы изменим какое-либо значение, оно также отразится на другом, потому что оба указывают на одну и ту же ссылку на память.

Опять же, вы имеете в виду изменение состояния одного объекта, на который ссылаются обе переменные .

Так почему это правило здесь не применяется? Если я присваиваю null для referToSample, тогда образец также должен иметь значение null, и он должен генерировать nullPointerException, но он не бросает, почему?

Опять же, вы изменяете ссылку на одну переменную, что абсолютно не влияет на ссылку на другую переменную.

Это два совершенно разных действия, которые приведут к двум совершенно разным результатам.

Смотрите эту простую диаграмму:

При вызове метода на referToSample, затем [your object]обновляется, так что это влияет sampleслишком. Но когда вы говорите referToSample = null, вы просто меняете то, к чему referToSample относится .

Здесь 'sample' и 'referToSample' ссылаются на один и тот же объект. Это концепция разных указателей, обращающихся к одной и той же области памяти. Таким образом, присвоение одной ссылочной переменной null не уничтожает объект.

   referToSample = null;

означает, что «referToSample» указывает только на null, объект остается таким же, а другая ссылочная переменная работает нормально. Итак, для 'образца', который не указывает на нуль и имеет действительный объект

   sample.append("A");

работает отлично. Но если мы попытаемся добавить null к «referToSample», он покажет исключение NullPointException. То есть,

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

Вот почему в третьем фрагменте кода есть исключение NullPointerException.

Всякий раз, когда используется новое ключевое слово, оно создает объект в куче

1) Пример StringBuilder = новый StringBuilder ();

2) StringBuilder referToSample = sample;

Во 2) Ссылка на referSample создается на том же образце объекта

таким образом, referToSample = null; Обнуляет Только ссылка referSample, не влияющая на образец, поэтому вы не получаете исключение указателя NULL благодаря сборке мусора Java

Просто в Java нет передачи по ссылке, она просто передает ссылку на объект.