Как передаются аргументы в Java

# Как передаются аргументы в Java

Основной принцип: Pass by Value

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

Примитивные типы:        Объекты:
┌─────────────┐          ┌──────────────┐
│ Значение    │          │ Ссылка       │
│ копируется  │          │ копируется   │
└─────────────┘          └──────────────┘
     ↓                           ↓
  Копия в методе         Копия ссылки указывает
  независима             на ТОТА же объект

Пример 1: Примитивные типы (pass by value)

public class PassByValueExample {
    
    public static void main(String[] args) {
        int x = 10;
        modifyInt(x);
        System.out.println("x = " + x);  // Вывод: x = 10
    }
    
    public static void modifyInt(int value) {
        value = 20;  // Изменяем копию значения
        System.out.println("Inside method: value = " + value);  // 20
    }
    
    // Объяснение:
    // 1. x = 10 создаётся в main
    // 2. modifyInt получает КОПИЮ значения 10
    // 3. Изменение копии не влияет на оригинальный x
    // 4. После вызова x остаётся 10
}

Пример 2: Объекты (передача копии ссылки)

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

public class PassByReferenceExample {
    
    public static void main(String[] args) {
        User user = new User("Alice");
        System.out.println("Before: " + user.name);  // Alice
        
        modifyUser(user);
        System.out.println("After: " + user.name);   // Bob
    }
    
    public static void modifyUser(User u) {
        u.name = "Bob";  // Изменяем объект через копию ссылки
    }
    
    // Объяснение:
    // 1. user указывает на объект User("Alice") в памяти
    // 2. modifyUser получает КОПИЮ ссылки (указывает на ТОТЖЕ объект)
    // 3. Изменение u.name влияет на оригинальный объект
    // 4. После вызова user.name = "Bob"
}

Ключевой момент: Переассигнация ссылки внутри метода

public class ReferencePassing {
    
    public static void main(String[] args) {
        User user = new User("Alice");
        System.out.println("Before: " + user.name);  // Alice
        
        replaceUser(user);
        System.out.println("After: " + user.name);   // Alice (не Bob!)
    }
    
    public static void replaceUser(User u) {
        // Создаём НОВЫЙ объект
        u = new User("Bob");
        System.out.println("Inside method: " + u.name);  // Bob
    }
    
    // Объяснение:
    // 1. user указывает на User("Alice")
    // 2. replaceUser получает копию ссылки
    // 3. Внутри метода: u = new User("Bob") переассигнирует КОПИЮ ссылки
    // 4. Оригинальный user в main остаётся неизменённым
    // 5. После вызова user.name всё ещё "Alice"
    
    // ВИЗУАЛЬНО:
    // main: user ──→ User("Alice") [не изменился]
    // replaceUser: u ──→ User("Bob") [новая ссылка в копии]
}

Пример 3: Массивы (это также объекты)

public class ArrayPassing {
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        modifyArray(arr);
        System.out.println("After: " + arr[0]);  // 100 (изменился!)
    }
    
    public static void modifyArray(int[] a) {
        a[0] = 100;  // Изменяем через ссылку на ТОТЖЕ массив
    }
    
    // Объяснение:
    // Массив — это объект
    // Ссылка на массив передаётся по значению (копия ссылки)
    // Но она указывает на ТОТЖЕ массив в памяти
}

Пример 4: String (immutable)

public class StringPassing {
    
    public static void main(String[] args) {
        String text = "Hello";
        modifyString(text);
        System.out.println("After: " + text);  // Hello (не изменился)
    }
    
    public static void modifyString(String s) {
        s = "World";  // Создаёт НОВЫЙ String объект
        System.out.println("Inside: " + s);   // World
    }
    
    // Объяснение:
    // String immutable (неизменяемый)
    // s = "World" создаёт НОВЫЙ String
    // Переассигнирует копию ссылки
    // Оригинальный text остаётся "Hello"
}

Таблица: Сравнение типов

public class ComparisonTable {
    
    public static void main(String[] args) {
        // 1. Примитивные типы
        int num = 5;
        modifyPrimitive(num);
        // num остаётся 5 ❌ не изменяется
        
        // 2. Объекты (mutable)
        User user = new User("Alice");
        modifyObject(user);
        // user.name = "Bob" ✅ изменяется
        
        // 3. Переассигнация объекта
        User user2 = new User("Alice");
        reassignObject(user2);
        // user2.name = "Alice" ❌ не изменяется
        
        // 4. Strings (immutable)
        String str = "Hello";
        modifyString(str);
        // str = "Hello" ❌ не изменяется
        
        // 5. Массивы
        int[] arr = {1, 2, 3};
        modifyArray(arr);
        // arr[0] = 100 ✅ изменяется
    }
}

Практический пример: Правильный паттерн для изменения параметра

public class ProperParameterModification {
    
    // ❌ Плохо: не работает
    public static void badTryToReturn(User user) throws Exception {
        user = new User("NewName");
        // Вызывающий код не увидит изменение
    }
    
    // ✅ Хорошо 1: возвращаем новый объект
    public static User goodReturnNewObject(User user) {
        return new User("NewName");
    }
    
    // ✅ Хорошо 2: изменяем свойства объекта
    public static void goodModifyProperties(User user) {
        user.setName("NewName");
    }
    
    // ✅ Хорошо 3: используем Wrapper или Container
    public static class UserContainer {
        public User user;
    }
    
    public static void goodUseContainer(UserContainer container) {
        container.user = new User("NewName");
    }
}

Сравнение с другими языками

// JAVA: Pass by Value (для ссылок — копия ссылки)
public static void java(User u) {
    u = new User("New");  // Не влияет на оригинальную ссылку
    u.name = "Modified";  // Влияет на объект!
}

// C#: Pass by Reference (если указано ref)
public static void csharp(ref User u) {
    u = new User("New");  // Влияет на оригинальную ссылку
}

// Python: Pass by Object Reference (похоже на Java)
def python(user):
    user = User("New")     # Не влияет
    user.name = "Modified" # Влияет

Вывод

В Java ВСЕ параметры передаются по значению:

• Для примитивов: передаётся копия значения ❌ изменения не влияют
• Для объектов: передаётся копия ссылки ✅ изменения свойств влияют на оригинальный объект
• Переассигнация ссылки внутри метода не влияет на оригинальную ссылку ❌

Этот механизм — источник частых ошибок на собеседованиях. Главное помнить: ссылка передаётся по значению (копируется), но она указывает на ТОТЖЕ объект в памяти.