Можно ли получить доступ к измененному значению аргумента примитива из вызывающего метода?

Ответ на вопрос о передаче примитивов по значению

Нет, нельзя

В Java всё передаётся по значению (pass-by-value). Для примитивных типов (int, double, boolean и т.д.) это означает, что метод работает с копией значения. Любые изменения внутри метода не повлияют на исходную переменную в вызывающем коде.

Как это работает

public static void modifyInt(int value) {
    value = 100; // Изменяем копию
}

public static void main(String[] args) {
    int original = 5;
    modifyInt(original);
    System.out.println(original); // Output: 5 (не изменилось!)
}

В этом примере:

1. Переменная original содержит значение 5
2. При вызове modifyInt(original) передаётся копия значения 5
3. Параметр value получает эту копию
4. Внутри метода меняется только копия
5. Исходная переменная original остаётся 5

Почему это так?

Java использует pass-by-value для всех типов данных:

• Примитивы: передаётся копия самого значения (int, long, double и т.д.)
• Объекты: передаётся копия ссылки, а не самого объекта

Это разные вещи! Для объектов можно менять содержимое через ссылку, но саму ссылку переприсвоить нельзя.

Различие: примитивы vs объекты

Примитивы

public static void modifyPrimitive(int x) {
    x = 99; // Меняется только локальная копия
}

public static void main(String[] args) {
    int num = 10;
    modifyPrimitive(num);
    System.out.println(num); // Output: 10
}

Объекты

public static void modifyObject(List<Integer> list) {
    list.add(5); // ✅ Изменение через ссылку видно снаружи
    list = new ArrayList<>(); // ❌ Переприсвоение не видно снаружи
}

public static void main(String[] args) {
    List<Integer> myList = new ArrayList<>();
    myList.add(1);
    myList.add(2);
    
    modifyObject(myList);
    System.out.println(myList); // Output: [1, 2, 5] - добавилось!
    System.out.println(myList.size()); // Output: 3
    // Но список не был переприсвоен новому ArrayList
}

Варианты решения

1. Использование объектов-обёрток

public static void modify(Integer[] value) {
    value[0] = 100; // Меняем содержимое массива
}

public static void main(String[] args) {
    Integer[] num = {5};
    modify(num);
    System.out.println(num[0]); // Output: 100 ✅
}

2. Использование AtomicInteger

public static void modify(AtomicInteger value) {
    value.set(100); // Меняем значение через метод
}

public static void main(String[] args) {
    AtomicInteger num = new AtomicInteger(5);
    modify(num);
    System.out.println(num.get()); // Output: 100 ✅
}

3. Возврат значения из метода

public static int modify(int value) {
    return value * 20; // Возвращаем новое значение
}

public static void main(String[] args) {
    int num = 5;
    num = modify(num); // Переприсваиваем результат
    System.out.println(num); // Output: 100 ✅
}

4. Использование кастомного класса

public class MutableInt {
    private int value;
    
    public MutableInt(int value) {
        this.value = value;
    }
    
    public void setValue(int value) {
        this.value = value;
    }
    
    public int getValue() {
        return value;
    }
}

public static void modify(MutableInt wrapper) {
    wrapper.setValue(100);
}

public static void main(String[] args) {
    MutableInt num = new MutableInt(5);
    modify(num);
    System.out.println(num.getValue()); // Output: 100 ✅
}

Лучшая практика

Рекомендуется использовать возврат значений — это более чистый и понятный подход:

public static int square(int x) {
    return x * x;
}

public static void main(String[] args) {
    int num = 5;
    num = square(num); // Явно видно, что значение меняется
    System.out.println(num); // Output: 25
}

Заключение

Примитивные типы в Java передаются по значению, поэтому изменения внутри метода не влияют на исходную переменную. Если нужно вернуть изменённое значение, используйте:

1. Возврат из метода (рекомендуется)
2. Объекты-обёртки (Integer[], AtomicInteger)
3. Кастомные классы для обёртки значений

Это фундаментальная особенность Java, а не баг!