Использование метода для изменения переменных

Question

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

import java.util.*;

class training
{
    static Scanner reader = new Scanner(System.in);
    public static void main (String[]args)
    {
        int [] a = new int [10];
        firstnum(a);
        System.out.println(Arrays.toString(a));
    }

    static void firstnum (int[] t)
    {
        for (int i =0; i < t.length; i++)
        t[i] = (int)(Math.random() * 101);
    }
}

Код рабочий. Выводит заполненный массив целых чисел. Обратите внимание: метод в котором заполняется массив имеет метку void, то есть не возвращает никакие значение но, почему то, заполняет массив.

Случай второй. Пытался сделать такое же с обычным целым числом. Код:

import java.util.*;

class training2
{
    static Scanner reader = new Scanner(System.in);
    public static void main (String[]args)
    {
        int a = 0;
        firstnum(a);
        System.out.println(a);
    }

    static void firstnum (int t)
    {
        t = 1;
    }
}

Выводит 0. Почему и как исправить? Заранее спасибо.

Answer 1

В Java все параметры передаются при вызове по значению (pass by value), однако передача примитивных и объектных типов несколько различается. Из-за этого различия, некоторые ошибочно говорят, что объекты в Java передаются при вызове по ссылке – и это принципиально неверно, так как при передаче объектов в Java передается не сама ссылка на объект, а копия этой ссылки.

При передаче примитивного типа происходит копирование значения в локальную переменную метода, соответственно, изменение этого значения в методе никак не повлияет на значение переменной вне метода.

При передаче объектного типа (а массив в Java является объектом) происходит копирование ссылки на этот объект в локальную переменную метода, соответственно, изменение состояния переданного объекта будет видно вне метода.

Стоит обратить внимание на передачу неизменяемых (immutable) объектов (например объектов типа String и всех оболочек примитивов: Integer, Float и т.д.): при изменении таких объектов создается новый объект, поэтому эти изменения извне видны не будут.

Касательно Ваших примеров:

В первом случае передается объект int[] t, соответственно, изменение его состояния будет видно извне.

Во втором случае передается примитив int t, соответственно, изменение значения этой переменной в методе не видно извне.

---

Есть еще такой термин: вызов по соиспользованию (call by sharing) – по сути, объекты в Java передаются именно так, но в данном контексте вызов по соиспользованию можно назвать некоторой разновидностью вызова по значению, поэтому в общем можно сказать, что в Java все параметры передаются при вызове по значению.

Answer 2

В этом нет никакой мистики, и тип метода - void или какой-то другой - к вопросу не имеет никакого отношения. Все дело в том, как в метод передаются параметры. Параметры примитивных типов (int, double и т. п.) передаются по значению - иными словами, при вызове метода создается неявная локальная (существующая только внутри этого метода) переменная, куда копируется значение, переданное в параметре. Недаром же это именно значение, например, это может быть значение выражения 5 + 10. Метод может делать со своим параметром что угодно - меняться будет только переменная, существующая внутри метода, никакие переменные в окружающем мире никак не изменятся. Вы же не ждете, что при вызове firstnum(5 + 10) пять превратиться в 10 или 10 в 20?

Другое дело - параметры объектных типов, к которым относятся и массивы. В этом случае в метод фактически передается ссылка на объект, и когда метод выполняет какие-то манипуляции с таким объектом, меняется сам исходный объект. В вашем первом примере параметр t фактически является ссылкой на массив a, описанный вне метода, и когда метод меняет значения элементов массива - это меняются элементы массива a. Это важно понимать и учитывать, иначе можно получить совсем не тот результат, который надо.

При это также надо помнить, что неизменяемые объекты (immutable), напр. String, а также объекты-оболочки (типа Integer, Double и т. п.) при передаче их в качестве параметров ведут себя в некотором смысле не как объекты, а как примитивные типы - хотя в метод передается ссылка на исходный объект, но при присваивании такому параметру нового значения внутри метода фактически создается новый объект с новым значением, и локальной переменной внутри метода присваивается ссылка на этот новый объект, а при завершении работы метода такой объект просто уничтожается. Исходный объект, ссылка на который был передан методу, при этом никак не меняется. Внешне это выглядит так, как при работе с примитивными типами - исходная переменная вне метода не меняется, что бы метод не делал со своими параметрами.

Answer 3

Видимо потому, что массив (хоть и тип int) делает автоупаковку (попробовать почитать тут) в Integer[], а Integer — это объект. Ну собсн объект передается по ссылке (кто-то скажет, что в Java все передается по значению и там статьи в инете всякие, но, не будем вдаваться в детали). И поэтому меняется.

А не массив, простой примитив не распаковывается. Поэтому ничего и не меняется.