Что произойдет если заменить ссылку на объект при изменении метода?

Что произойдет если заменить ссылку на объект при изменении метода?

В Java передача объектов в методы работает через передачу ссылки по значению (pass-by-value of reference). Это означает, что вы передаёте копию ссылки, а не саму переменную. Если заменить эту ссылку внутри метода, оригинальная переменная останется неизменённой — она будет указывать на старый объект.

Как работает передача ссылок

public class Dog {
    private String name;
    
    public Dog(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

public class Main {
    
    // Метод, который МЕНЯЕТ ССЫЛКУ
    public static void changeDog(Dog dog) {
        dog = new Dog("Rex");  // Заменяем локальную ссылку
        System.out.println("Внутри метода: " + dog.getName());  // Rex
    }
    
    public static void main(String[] args) {
        Dog myDog = new Dog("Max");
        System.out.println("До метода: " + myDog.getName());  // Max
        
        changeDog(myDog);  // Передаём ссылку
        
        System.out.println("После метода: " + myDog.getName());  // Max!
    }
}

// Вывод:
// До метода: Max
// Внутри метода: Rex
// После метода: Max

Что произошло:

1. myDog указывает на объект Dog("Max")
2. Вызываем changeDog(myDog) — передаём ссылку
3. Параметр dog метода указывает на ТОТ ЖЕ объект Dog("Max")
4. НО: dog = new Dog("Rex") — меняем ЛОКАЛЬНУЮ переменную dog
5. Теперь dog указывает на новый объект, но myDog по-прежнему указывает на старый
6. После выхода из метода переменная dog удаляется (локальная переменная)
7. myDog остаётся неизменённой

Визуально (куча памяти)

До вызова:
  Стек (Stack)          Куча (Heap)
  ┌─────────────┐      ┌──────────────────┐
  │ myDog   ────┼──────┼→ Dog("Max")      │
  └─────────────┘      └──────────────────┘

Внутри changeDog():
  Стек (Stack)          Куча (Heap)
  ┌─────────────┐      ┌──────────────────┐
  │ dog     ────┼──────┼→ Dog("Rex") [NEW] │
  │             │      └──────────────────┘
  │ myDog   ────┼────┐ ┌──────────────────┐
  │             │    └─┼→ Dog("Max")      │
  └─────────────┘      └──────────────────┘

После выхода из метода:
  Стек (Stack)          Куча (Heap)
  ┌─────────────┐      ┌──────────────────┐
  │ myDog   ────┼──────┼→ Dog("Max")      │
  └─────────────┘      └──────────────────┘
                       
  Dog("Rex") удалён сборщиком мусора, так как на него никто не ссылается

Правило: передача по значению ссылки

public class Reference {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        
        // Сценарий 1: Меняем состояние объекта
        modifyObject(sb);
        System.out.println(sb);  // Hello World
        
        // Сценарий 2: Меняем саму ссылку
        replaceReference(sb);
        System.out.println(sb);  // Hello World (не изменилась!)
    }
    
    // Сценарий 1: Меняем содержимое объекта - РАБОТАЕТ
    public static void modifyObject(StringBuilder sb) {
        sb.append(" World");  // Меняем состояние
    }
    
    // Сценарий 2: Меняем саму ссылку - НЕ РАБОТАЕТ
    public static void replaceReference(StringBuilder sb) {
        sb = new StringBuilder("New");  // Меняем ссылку, оригинал не меняется
    }
}

Практический пример с реальной проблемой

public class User {
    private String name;
    private int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class UserService {
    
    // НЕПРАВИЛЬНО: попытка заменить ссылку
    public static void updateUser(User user, String newName) {
        user = new User(newName, 0);  // Не сработает!
    }
    
    // ПРАВИЛЬНО: изменять состояние объекта
    public static void updateUser(User user, String newName) {
        // Было бы хорошо иметь setter или вспомогательный метод
        // Это зависит от дизайна класса User
    }
    
    // ИЛИ: вернуть новый объект
    public static User createUpdatedUser(User user, String newName) {
        return new User(newName, user.age);
    }
}

public class Main {
    public static void main(String[] args) {
        User user = new User("John", 30);
        
        // Попытка обновить
        UserService.updateUser(user, "Jane");
        // user.name остаётся "John" - не изменилась!
        
        // Правильный способ
        user = UserService.createUpdatedUser(user, "Jane");
        // Теперь user указывает на новый объект с именем "Jane"
    }
}

Особенность: примитивные типы

Для примитивных типов то же самое — замена локальной переменной не влияет на оригинал:

public static void changeValue(int x) {
    x = 100;  // Меняем локальную копию
}

public static void main(String[] args) {
    int x = 5;
    changeValue(x);
    System.out.println(x);  // Всё ещё 5
}

Как ПРАВИЛЬНО передать объект для изменения

Вариант 1: Возвращать новый объект

public static User updateUser(User user, String newName) {
    return new User(newName, user.getAge());
}

// Использование
user = updateUser(user, "Jane");

Вариант 2: Передавать параметры в конструктор или factory метод

public static void main(String[] args) {
    User user = new User("John", 30);
    
    // Создаём новый объект, присваиваем переменной
    user = new User("Jane", user.getAge());
}

Вариант 3: Если объект mutable, менять его состояние

public class User {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
}

public static void updateUser(User user, String newName) {
    user.setName(newName);  // Меняем состояние, не ссылку
}

// Использование
User user = new User("John");
updateUser(user, "Jane");
// Теперь user.name = "Jane"

Пример с List (Collection)

public static void replaceList(List<String> list) {
    list = new ArrayList<>();  // Меняем локальную ссылку
    list.add("New");
}

public static void main(String[] args) {
    List<String> myList = new ArrayList<>();
    myList.add("Old");
    
    replaceList(myList);
    
    System.out.println(myList);  // [Old] - не изменилась!
}

Правильно:

public static List<String> replaceList(List<String> list) {
    List<String> newList = new ArrayList<>();
    newList.add("New");
    return newList;  // Возвращаем новый список
}

public static void main(String[] args) {
    List<String> myList = new ArrayList<>();
    myList.add("Old");
    
    myList = replaceList(myList);  // Присваиваем возвращённое значение
    
    System.out.println(myList);  // [New]
}

Или меняем содержимое, не ссылку

public static void updateList(List<String> list) {
    list.clear();  // Очищаем СОДЕРЖИМОЕ
    list.add("Updated");  // Добавляем новое значение
}

public static void main(String[] args) {
    List<String> myList = new ArrayList<>();
    myList.add("Old");
    
    updateList(myList);
    
    System.out.println(myList);  // [Updated] - изменилась содержимость!
}

Важный вывод

Правило передачи параметров в Java:

Практическое значение

// ❌ НЕПРАВИЛЬНО: попытка заменить ссылку
public User initializeUser(User user) {
    user = new User("John");  // НЕ СРАБОТАЕТ
    return user;  // Возвращаем ссылку, но оригинальная переменная не менялась
}

// ✅ ПРАВИЛЬНО: возвращаем новый объект
public User initializeUser() {
    return new User("John");  // Клиент сам присвоит результат
}

// ✅ ПРАВИЛЬНО: меняем состояние
public void initializeUser(User user) {
    user.setName("John");  // Меняем содержимое объекта
}

Вывод: если заменить ссылку на объект внутри метода (через new), оригинальная переменная останется неизменённой, так как Java передаёт копию ссылки, а не саму переменную. Нужно либо возвращать новый объект, либо менять состояние существующего через методы, либо использовать setter'ы.