Является ли Java «передачей по ссылке» или «передачей по значению»?

Я всегда думал, что Java была по ссылке .

Тем не менее, я видел пару постов в блоге (например, этот блог ), которые утверждают, что это не так.

Я не думаю, что понимаю разницу, которую они проводят.

Какое объяснение?

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

Это выглядит так:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    // we pass the object to foo
    foo(aDog);
    // aDog variable is still pointing to the "Max" dog when foo(...) returns
    aDog.getName().equals("Max"); // true
    aDog.getName().equals("Fifi"); // false
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // change d inside of foo() to point to a new Dog instance "Fifi"
    d = new Dog("Fifi");
    d.getName().equals("Fifi"); // true
}

В приведенном выше примере aDog.getName()все еще вернется "Max". Значение в aDogпределах mainне изменяется в функции fooс Dog "Fifi"как ссылка на объект передается по значению. Если бы он был передан по ссылке, то после вызова к возвращается aDog.getName()in .main"Fifi"foo

Точно так же:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    foo(aDog);
    // when foo(...) returns, the name of the dog has been changed to "Fifi"
    aDog.getName().equals("Fifi"); // true
    // but it is still the same dog:
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // this changes the name of d to be "Fifi"
    d.setName("Fifi");
}

В приведенном выше примере Fifiэто имя собаки после вызова, foo(aDog)потому что имя объекта было установлено внутри foo(...). Любые операции , которые fooвыполняют на dтаковы , что для всех практических целей, они выполняются на aDog, но это не возможно изменить значение переменного aDogсам.

Я только что заметил, что вы ссылались на мою статью .

Спецификация Java говорит, что все в Java передается по значению. В Java нет такого понятия, как «передача по ссылке».

Ключом к пониманию этого является то, что

Dog myDog;

это не собака; это на самом деле указатель на собаку.

Что это значит, когда у вас есть

Dog myDog = new Dog("Rover");
foo(myDog);

вы по сути передаете адрес созданного Dogобъекта fooметоду.

(Я говорю по существу, потому что указатели Java не являются прямыми адресами, но проще всего так думать о них)

Предположим, что Dogобъект находится по адресу памяти 42. Это означает, что мы передаем 42 методу.

если метод был определен как

public void foo(Dog someDog) {
    someDog.setName("Max");     // AAA
    someDog = new Dog("Fifi");  // BBB
    someDog.setName("Rowlf");   // CCC
}

давайте посмотрим на то, что происходит.

• для параметра someDogустановлено значение 42
• на линии "ААА"
  • someDogследует к Dogнему указывает ( Dogобъект по адресу 42)
  • что Dog(тот, по адресу 42) попросили изменить его имя на Макс
• на линии "ВВВ"
  • новый Dogсоздан. Допустим, он по адресу 74
  • мы назначаем параметр someDog74
• на линии "CCC"
  • SomeDog следует на Dogэто указывает ( Dogобъект по адресу 74)
  • что Dog(тот по адресу 74) попросили изменить его имя на Rowlf
• тогда мы вернемся

Теперь давайте подумаем о том, что происходит вне метода:

Изменился myDog?

Там ключ.

Помня, что myDogэто указатель , а не факт Dog, ответ НЕТ. myDogпо-прежнему имеет значение 42; он по-прежнему указывает на оригинал Dog(но обратите внимание, что из-за строки «AAA» его имя теперь «Макс» - все тот же Dog; myDogзначение не изменилось.)

Совершенно верно следовать за адресом и изменять то, что в конце этого; это не меняет переменную, однако.

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

В C ++, Ada, Pascal и других языках, которые поддерживают передачу по ссылке, вы действительно можете изменить переданную переменную.

Если бы у Java была семантика передачи по ссылке, то fooметод, который мы определили выше, изменился бы там, куда myDogуказывал, когда он был назначен someDogв строке BBB.

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

Java всегда передает аргументы по значению , а не по ссылке.

Позвольте мне объяснить это на примере :

public class Main {

     public static void main(String[] args) {
          Foo f = new Foo("f");
          changeReference(f); // It won't change the reference!
          modifyReference(f); // It will modify the object that the reference variable "f" refers to!
     }

     public static void changeReference(Foo a) {
          Foo b = new Foo("b");
          a = b;
     }

     public static void modifyReference(Foo c) {
          c.setAttribute("c");
     }

}

Я объясню это по шагам:

1. Объявить ссылку с именем fтипа Fooи назначить ей новый объект типа Fooс атрибутом "f".

   Foo f = new Foo("f");

   

2. Со стороны метода объявляется ссылка на тип Fooс именем, aи она изначально присваивается null.

   public static void changeReference(Foo a)

   

3. Когда вы вызываете метод changeReference, ссылке aбудет присвоен объект, который передается в качестве аргумента.

   changeReference(f);

   

4. Объявить ссылку с именем bтипа Fooи назначить ей новый объект типа Fooс атрибутом "b".

   Foo b = new Foo("b");

   

5. a = bсоздает новое назначение для ссылки a, а не f для объекта, чьим атрибутом является "b".

   

6. Когда вы вызываете modifyReference(Foo c)метод, создается ссылка cи назначается объект с атрибутом "f".

   

7. c.setAttribute("c");изменит атрибут объекта, на который cуказывает ссылка , и тот же объект, на который fуказывает ссылка .

   

Надеюсь, теперь вы понимаете, как передача объектов в качестве аргументов работает в Java :)

Это даст вам некоторое представление о том, как на самом деле работает Java, до такой степени, что в вашем следующем обсуждении передачи Java по ссылке или по значению вы просто улыбнетесь :-)

Шаг первый, пожалуйста, удалите из памяти это слово, которое начинается с 'p' "_ _ _ _ _ _ _", особенно если вы пришли из других языков программирования. Java и 'p' не могут быть записаны в одной книге, на форуме или даже в txt.

Шаг второй Помните, что когда вы передаете Object в метод, вы передаете ссылку на Object, а не сам объект.

• Ученик : Магистр, означает ли это, что Java передается по ссылке?
• Мастер : Кузнечик, №

Теперь подумайте о том, что ссылка / переменная объекта делает / является:

1. Переменная содержит биты, которые сообщают JVM, как добраться до ссылочного объекта в памяти (кучи).
2. При передаче аргументов методу вы НЕ передаете ссылочную переменную, а копируете биты в ссылочной переменной . Как то так: 3bad086a. 3bad086a представляет способ добраться до пропущенного объекта.
3. Итак, вы просто передаете 3bad086a, что это значение ссылки.
4. Вы передаете значение ссылки, а не саму ссылку (и не объект).
5. Это значение фактически копируется и передается методу .

В следующем (пожалуйста, не пытайтесь скомпилировать / выполнить это ...):

1. Person person;
2. person = new Person("Tom");
3. changeName(person);
4.
5. //I didn't use Person person below as an argument to be nice
6. static void changeName(Person anotherReferenceToTheSamePersonObject) {
7.     anotherReferenceToTheSamePersonObject.setName("Jerry");
8. }

Что просходит?

• Переменная person создается в строке # 1 и в начале имеет значение null.
• Новый объект Person создается в строке # 2, сохраняется в памяти, а переменной person дается ссылка на объект Person. То есть его адрес. Допустим, 3bad086a.
• Переменная person, содержащая адрес объекта, передается функции в строке # 3.
• В строке № 4 вы можете прослушать звук тишины
• Проверьте комментарий в строке № 5
• Локальная переменная метода - anotherReferenceToTheSamePersonObject - создается, а затем появляется волшебство в строке # 6:
  • Переменная / эталонное лицо копируется побитно и передается в другойReferenceToTheSamePersonObject внутри функции.
  • Новые экземпляры Person не создаются.
  • И " person ", и " anotherReferenceToTheSamePersonObject " содержат одно и то же значение 3bad086a.
  • Не пытайтесь это сделать, но person == anotherReferenceToTheSamePersonObject будет истинным.
  • Обе переменные имеют ИДЕНТИЧНЫЕ КОПИИ ссылки, и они обе ссылаются на один и тот же объект Person, ОДИН ЖЕ объект в куче и НЕ КОПИЮ.

Одна картинка стоит тысячи слов:

Обратите внимание, что стрелки anotherReferenceToTheSamePersonObject направлены на объект, а не на переменную person!

Если вы не получили его, просто поверьте мне и помните, что лучше сказать, что Java передается по значению . Ну, перейдите по ссылке . Ну что ж, еще лучше, если передать значение переменной! ;)

Теперь не стесняйтесь ненавидеть меня, но обратите внимание, что с учетом этого нет разницы между передачей примитивных типов данных и объектов при обсуждении аргументов метода.

Вы всегда передаете копию битов значения ссылки!

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

Java передается по значению, потому что внутри метода вы можете изменять ссылочный объект столько раз, сколько хотите, но как бы вы ни старались, вы никогда не сможете изменить переданную переменную, которая будет продолжать ссылаться (не p _ _ _) _ _ _ _) один и тот же объект, несмотря ни на что!

Приведенная выше функция changeName никогда не сможет изменить фактическое содержимое (значения битов) переданной ссылки. Другими словами, changeName не может заставить человека ссылаться на другой объект.

Конечно, вы можете сократить его и просто сказать, что Java передается по значению!

Java всегда передается по значению, без исключений, никогда .

Так почему же это может смущать любого, кто верит, что Java передается по ссылке, или думает, что у него есть пример того, как Java действует как передача по ссылке? Ключевым моментом является то, что Java никогда не обеспечивает прямого доступа к значениям самих объектов ни при каких обстоятельствах. Единственный доступ к объектам - через ссылку на этот объект. Поскольку доступ к объектам Java всегда осуществляется через ссылку, а не напрямую, обычно говорят о полях, переменных и аргументах методов как об объектах , когда педантично они являются только ссылками на объекты .Путаница проистекает из этого (строго говоря, неверного) изменения в номенклатуре.

Итак, при вызове метода

• Для аргументов примитива ( int, longи т. Д.) Передача по значению является фактическим значением примитива (например, 3).
• Для объектов передача по значению является значением ссылки на объект .

Так что если у вас есть doSomething(foo)и public void doSomething(Foo foo) { .. }два Foos скопировали ссылки, которые указывают на одни и те же объекты.

Естественно, передача по значению ссылки на объект очень похожа (и практически не отличается от) передачи объекта по ссылке.

Java передает ссылки по значению.

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

Я чувствую, что спор о «передача по ссылке против передачи по значению» не является супер-полезным.

Если вы говорите: «Java является передачей по любому (ссылка / значение)», в любом случае вы не дадите полного ответа. Вот некоторая дополнительная информация, которая, надеюсь, поможет понять, что происходит в памяти.

Ускоренный курс по стеку / куче, прежде чем мы перейдем к реализации Java: значения идут и выходят из стека хорошим упорядоченным образом, как стопка тарелок в кафетерии. Память в куче (также известная как динамическая память) является случайной и дезорганизованной. JVM просто находит место, где только может, и освобождает его, поскольку переменные, которые его используют, больше не нужны.

Ладно. Во-первых, локальные примитивы идут в стек. Итак, этот код:

int x = 3;
float y = 101.1f;
boolean amIAwesome = true;

Результаты в этом:

Когда вы объявляете и создаете экземпляр объекта. Фактический объект идет в кучу. Что идет в стек? Адрес объекта в куче. Программисты C ++ назвали бы это указателем, но некоторые Java-разработчики против слова «указатель». Без разницы. Просто знайте, что адрес объекта уходит в стек.

Вот так:

int problems = 99;
String name = "Jay-Z";

Массив - это объект, поэтому он также попадает в кучу. А как насчет объектов в массиве? Они получают свое собственное пространство кучи, и адрес каждого объекта идет внутри массива.

JButton[] marxBros = new JButton[3];
marxBros[0] = new JButton("Groucho");
marxBros[1] = new JButton("Zeppo");
marxBros[2] = new JButton("Harpo");

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

private static void shout(String name){
    System.out.println("There goes " + name + "!");
}

public static void main(String[] args){
    String hisName = "John J. Jingleheimerschmitz";
    String myName = hisName;
    shout(myName);
}

Создается одна строка, и место для нее выделяется в куче, а адрес строки сохраняется в стеке и получает идентификатор hisName, поскольку адрес второй строки совпадает с первым, новая строка не создается и новое пространство кучи не выделяется, но в стеке создается новый идентификатор. Затем мы вызываем shout(): создается новый кадр стека и создается новый идентификатор, nameи ему присваивается адрес уже существующей строки.

Итак, ценность, ссылка? Вы говорите "картофель".

Просто чтобы показать контраст, сравните следующие фрагменты C ++ и Java :

В C ++: Примечание: плохой код - утечки памяти! Но это демонстрирует суть.

void cppMethod(int val, int &ref, Dog obj, Dog &objRef, Dog *objPtr, Dog *&objPtrRef)
{
    val = 7; // Modifies the copy
    ref = 7; // Modifies the original variable
    obj.SetName("obj"); // Modifies the copy of Dog passed
    objRef.SetName("objRef"); // Modifies the original Dog passed
    objPtr->SetName("objPtr"); // Modifies the original Dog pointed to 
                               // by the copy of the pointer passed.
    objPtr = new Dog("newObjPtr");  // Modifies the copy of the pointer, 
                                   // leaving the original object alone.
    objPtrRef->SetName("objRefPtr"); // Modifies the original Dog pointed to 
                                    // by the original pointer passed. 
    objPtrRef = new Dog("newObjPtrRef"); // Modifies the original pointer passed
}

int main()
{
    int a = 0;
    int b = 0;
    Dog d0 = Dog("d0");
    Dog d1 = Dog("d1");
    Dog *d2 = new Dog("d2");
    Dog *d3 = new Dog("d3");
    cppMethod(a, b, d0, d1, d2, d3);
    // a is still set to 0
    // b is now set to 7
    // d0 still have name "d0"
    // d1 now has name "objRef"
    // d2 now has name "objPtr"
    // d3 now has name "newObjPtrRef"
}

В Java

public static void javaMethod(int val, Dog objPtr)
{
   val = 7; // Modifies the copy
   objPtr.SetName("objPtr") // Modifies the original Dog pointed to 
                            // by the copy of the pointer passed.
   objPtr = new Dog("newObjPtr");  // Modifies the copy of the pointer, 
                                  // leaving the original object alone.
}

public static void main()
{
    int a = 0;
    Dog d0 = new Dog("d0");
    javaMethod(a, d0);
    // a is still set to 0
    // d0 now has name "objPtr"
}

Java имеет только два типа передачи: по значению для встроенных типов и по значению указателя для типов объектов.

Java передает ссылки на объекты по значению.

По сути, переназначение параметров объекта не влияет на аргумент, например,

private void foo(Object bar) {
    bar = null;
}

public static void main(String[] args) {
    String baz = "Hah!";
    foo(baz);
    System.out.println(baz);
}

распечатает "Hah!"вместо null. Причина, по которой это работает, заключается в том, что barэто копия значения baz, которое является просто ссылкой на "Hah!". Если бы это было само собой фактическое задание, тогда fooбы переопределена bazв null.

Я не могу поверить, что никто еще не упомянул Барбару Лисков. Когда она разработала CLU в 1974 году, она столкнулась с той же проблемой терминологии, и она изобрела термин вызов путем разделения (также известный как вызов посредством разделения объектов и вызов по объекту ) для этого конкретного случая «вызов по значению, где значение равно ссылка".

Суть дела в том, что слово « ссылка» в выражении «передача по ссылке» означает нечто совершенно отличное от обычного значения слова « ссылка» в Java.

Обычно в Java ссылка означает ссылку на объект . Но технические термины, передаваемые по ссылке / значению из теории языка программирования, говорят о ссылке на ячейку памяти, содержащую переменную , что является чем-то совершенно другим.

В Java все ссылки, поэтому, когда у вас есть что-то вроде: Point pnt1 = new Point(0,0);Java делает следующее:

1. Создает новый объект Point
2. Создает новую ссылку Point и инициализирует эту ссылку точкой (ссылкой) на ранее созданный объект Point.
3. Отсюда, через жизнь объекта Point, вы получите доступ к этому объекту через ссылку pnt1. Таким образом, мы можем сказать, что в Java вы манипулируете объектом через его ссылку.
   

Java не передает аргументы метода по ссылке; он передает их по значению. Я буду использовать пример с этого сайта :

public static void tricky(Point arg1, Point arg2) {
  arg1.x = 100;
  arg1.y = 100;
  Point temp = arg1;
  arg1 = arg2;
  arg2 = temp;
}
public static void main(String [] args) {
  Point pnt1 = new Point(0,0);
  Point pnt2 = new Point(0,0);
  System.out.println("X1: " + pnt1.x + " Y1: " +pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);
  System.out.println(" ");
  tricky(pnt1,pnt2);
  System.out.println("X1: " + pnt1.x + " Y1:" + pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);  
}

Ход программы:

Point pnt1 = new Point(0,0);
Point pnt2 = new Point(0,0);

Создание двух разных объектов Point с двумя разными ссылками.

System.out.println("X1: " + pnt1.x + " Y1: " +pnt1.y); 
System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);
System.out.println(" ");

Ожидаемый результат будет:

X1: 0     Y1: 0
X2: 0     Y2: 0

В этой строке «передача по значению» входит в игру ...

tricky(pnt1,pnt2);           public void tricky(Point arg1, Point arg2);

Список литература pnt1и pnt2которые передаются по значению к хитрому способу, что означает , что теперь ваши ссылки pnt1и pnt2имеют их copiesимени arg1и arg2.so pnt1и arg1 точки на тот же объект. (То же самое для pnt2и arg2)

В trickyметоде:

 arg1.x = 100;
 arg1.y = 100;

Далее в trickyметоде

Point temp = arg1;
arg1 = arg2;
arg2 = temp;

Здесь вы сначала создаете новую tempссылку на точку, которая будет указывать на то же место, что и arg1ссылка. Затем вы перемещаете ссылку, arg1чтобы указать на то же место, что и arg2ссылка. Наконец arg2будет указывать на то же место , как temp.

Отсюда сфера trickyметода нет , и вы не имеете доступа больше к ссылкам: arg1, arg2, temp. Но важно отметить, что все, что вы делаете с этими ссылками, когда они «в жизни», будет постоянно влиять на объект, на который они указывают .

Итак, после выполнения метода tricky, когда вы вернетесь к main, у вас будет такая ситуация:

Итак, теперь полностью выполнение программы будет:

X1: 0         Y1: 0
X2: 0         Y2: 0
X1: 100       Y1: 100
X2: 0         Y2: 0

Java всегда передается по значению, а не по ссылке

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

Передача по значению означает, что вы делаете копию в памяти фактического значения параметра, которое передается. Это копия содержимого фактического параметра .

Передача по ссылке (также называемая передачей по адресу) означает, что копия адреса фактического параметра сохраняется .

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

public class PassByValue {
    public static void main(String[] args) {
        Test t = new Test();
        t.name = "initialvalue";
        new PassByValue().changeValue(t);
        System.out.println(t.name);
    }

    public void changeValue(Test f) {
        f.name = "changevalue";
    }
}

class Test {
    String name;
}

Выход этой программы:

changevalue

Давайте разберемся шаг за шагом:

Test t = new Test();

Как мы все знаем, он создаст объект в куче и вернет значение ссылки обратно в t. Например, предположим, что значение t равно 0x100234(мы не знаем фактическое внутреннее значение JVM, это только пример).

new PassByValue().changeValue(t);

При передаче ссылки t в функцию она не будет напрямую передавать фактическое значение ссылки объекта test, но создаст копию t и затем передаст ее функции. Поскольку он передается по значению , он передает копию переменной, а не фактическую ссылку на нее. Поскольку мы сказали, что значение t было 0x100234, и t, и f будут иметь одинаковое значение, и, следовательно, они будут указывать на один и тот же объект.

Если вы измените что-либо в функции, используя ссылку f, это изменит существующее содержимое объекта. Вот почему мы получили вывод changevalue, который обновляется в функции.

Чтобы понять это более четко, рассмотрим следующий пример:

public class PassByValue {
    public static void main(String[] args) {
        Test t = new Test();
        t.name = "initialvalue";
        new PassByValue().changeRefence(t);
        System.out.println(t.name);
    }

    public void changeRefence(Test f) {
        f = null;
    }
}

class Test {
    String name;
}

Будет ли это бросить NullPointerException? Нет, потому что он передает только копию ссылки. В случае передачи по ссылке он мог бы выбросить NullPointerException, как показано ниже:

Надеюсь, это поможет.

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

Получив внешний вид коробки, давайте посмотрим на сборку или некоторое низкоуровневое управление памятью. На уровне ЦП ссылка на что-либо сразу становится значением, если оно записывается в память или в один из регистров ЦП. (Вот почему указатель является хорошим определением. Это значение, которое одновременно имеет цель).

Данные в памяти имеют местоположение, и в этом месте есть значение (байт, слово, что угодно). В Assembly у нас есть удобное решение для присвоения имени определенному местоположению (он же переменная), но при компиляции кода ассемблер просто заменяет имя указанным местоположением, как ваш браузер заменяет доменные имена на IP-адреса.

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

Допустим, у нас есть переменная Foo, ее Location находится на 47-м байте в памяти, а ее значение равно 5. У нас есть другая переменная Ref2Foo, которая на 223-м байте в памяти, и ее значение будет 47. Этот Ref2Foo может быть технической переменной , явно не созданный программой. Если вы просто посмотрите на 5 и 47 без какой-либо другой информации, вы увидите только два значения . Если вы используете их в качестве ссылок, чтобы добраться до 5нас, мы должны путешествовать:

(Name)[Location] -> [Value at the Location]
---------------------
(Ref2Foo)[223]  -> 47
(Foo)[47]       -> 5

Вот как работают таблицы переходов.

Если мы хотим вызвать метод / функцию / процедуру со значением Foo, существует несколько возможных способов передачи переменной в метод, в зависимости от языка и нескольких режимов вызова метода:

1. 5 копируется в один из регистров процессора (т. Е. EAX).
2. 5 получает PUSHd в стек.
3. 47 копируется в один из регистров процессора
4. 47 PUSHd в стек.
5. 223 копируется в один из регистров ЦП.
6. 223 получает PUSHd в стек.

В каждом случае выше значения - копия существующего значения - была создана, теперь это должен получить метод обработки. Когда вы пишете «Foo» внутри метода, он либо считывается из EAX, либо автоматически разыменовывается , либо разыменовывается дважды, процесс зависит от того, как работает язык и / или от того, что диктует тип Foo. Это скрыто от разработчика, пока она не обходит процесс разыменования. Таким образом, ссылка - это значение, когда оно представлено, потому что ссылка - это значение, которое должно быть обработано (на уровне языка).

Теперь мы передали Foo методу:

• в случаях 1. и 2. если вы измените Foo ( Foo = 9), это повлияет только на локальную область, поскольку у вас есть копия значения. Изнутри метода мы даже не можем определить, где в памяти находился оригинальный Foo.
• в случаях 3. и 4. если вы используете языковые конструкции по умолчанию и изменяете Foo ( Foo = 11), это может изменить Foo глобально (зависит от языка, т. е. Java или типа procedure findMin(x, y, z: integer;var m Паскаля : integer);). Однако, если язык позволяет обойти процесс разыменования, вы можете изменить его 47, скажем, на 49. В этот момент кажется, что Foo изменился, если вы прочитали его, потому что вы изменили локальный указатель на него. И если вы захотите изменить этот Foo внутри метода ( Foo = 12), вы, вероятно, откажетесь от выполнения программы (aka. Segfault), поскольку вы будете писать в память, отличную от ожидаемой, вы даже можете изменить область, предназначенную для хранения исполняемого файла. Программа и запись в нее изменят выполняемый код (Foo сейчас нет 47). НО ценность Фу47не изменился глобально, только один внутри метода, потому что 47был также копией метода.
• в случаях 5. и 6. если вы изменяете 223внутри метода, он создает тот же хаос, что и в 3. или 4. (указатель, указывающий на неверное значение, которое снова используется в качестве указателя), но это все еще локальный проблема, так как 223 было скопировано . Однако, если вы сможете разыменовать Ref2Foo(то есть 223), достигнуть и изменить указанное значение 47, скажем, чтобы 49, это повлияет на Foo глобально , потому что в этом случае методы получили копию, 223 но указанная ссылка 47существует только один раз, и изменение этого чтобы 49приведет каждое Ref2Fooдвойное разыменование к неправильному значению.

Не обращая внимания на незначительные детали, даже языки, которые передают по ссылке, будут передавать значения в функции, но эти функции знают, что они должны использовать его для разыменования. Эта передача-ссылка-как-значение просто скрыта от программиста, потому что она практически бесполезна, а терминология - только передача по ссылке .

Строгая передача по значению также бесполезна, это будет означать, что 100-мегабайтный массив должен копироваться каждый раз, когда мы вызываем метод с массивом в качестве аргумента, поэтому Java не может строго передаваться по значению. Каждый язык передает ссылку на этот огромный массив (в качестве значения) и использует механизм копирования при записи, если этот массив можно изменить локально внутри метода, или позволяет методу (как это делает Java) изменять массив глобально (из представление вызывающего абонента) и несколько языков позволяет изменять значение самой ссылки.

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

Java это вызов по значению

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

• Вы всегда передаете копию битов значения ссылки!

• Если это примитивный тип данных, эти биты содержат значение самого примитивного типа данных, поэтому, если мы изменим значение заголовка внутри метода, то это не будет отражать изменения снаружи.

• Если это тип данных объекта, такой как Foo, foo = new Foo (), то в этом случае копия адреса объекта проходит как ярлык файла, предположим, что у нас есть текстовый файл abc.txt в C: \ desktop, и предположим, что мы сделали ярлык тот же файл и поместите его в C: \ desktop \ abc-ярлык, чтобы при доступе к файлу из C: \ desktop \ abc.txt и записи «Переполнение стека» и закрытии файла снова открывался файл из ярлыка, затем вы напишите «самое большое онлайн-сообщество для изучения программистами», тогда общее изменение файла будет «Stack Overflow - это крупнейшее онлайн-сообщество для обучения программистов»это означает, что не имеет значения, откуда вы открываете файл, каждый раз, когда мы обращались к одному и тому же файлу, здесь мы можем принять Foo в качестве файла и предположить, что foo хранится в 123hd7h (исходный адрес, такой как C: \ desktop \ abc.txt ) address и 234jdid (скопированный адрес, такой как C: \ desktop \ abc-ярлык, который на самом деле содержит оригинальный адрес файла внутри). Так что для лучшего понимания создайте ярлык файла и почувствуйте ..

Уже есть отличные ответы, которые охватывают это. Я хотел внести небольшой вклад, поделившись очень простым примером (который будет скомпилирован), сравнивающим поведение между передачей по ссылке в c ++ и передачей по значению в Java.

Несколько моментов:

1. Термин «ссылка» перегружен двумя значениями. В Java это просто означает указатель, но в контексте «Передачи по ссылке» это означает дескриптор исходной переменной, которая была передана.
2. Java это передача по значению . Java является потомком C (среди других языков). До C некоторые (но не все) более ранние языки, такие как FORTRAN и COBOL, поддерживали PBR, но C - нет. PBR позволил этим другим языкам вносить изменения в передаваемые переменные внутри подпрограмм. Чтобы выполнить то же самое (т.е. изменить значения переменных внутри функций), программисты на Си передавали указатели на переменные в функции. Языки, вдохновленные C, такие как Java, заимствовали эту идею и продолжают передавать указатели на методы, как это делал C, за исключением того, что Java вызывает свои указатели References. Опять же, это слово используется по-другому, чем в «Pass-By-Reference».
3. C ++ допускает передачу по ссылке , объявляя ссылочный параметр с помощью символа «&» (который является тем же символом, который используется для обозначения «адреса переменной» как в C, так и в C ++). Например, если мы передаем указатель по ссылке, параметр и аргумент не просто указывают на один и тот же объект. Скорее, это одна и та же переменная. Если один из них настроен на другой адрес или имеет значение NULL, то же самое можно сказать и о другом.
4. В приведенном ниже примере C ++ я передаю указатель на завершенную нулем строку по ссылке . И в приведенном ниже примере с Java я передаю ссылку Java на строку (опять же, как указатель на строку) по значению. Обратите внимание на вывод в комментариях.

C ++ передаем по справочному примеру:

using namespace std;
#include <iostream>

void change (char *&str){   // the '&' makes this a reference parameter
    str = NULL;
}

int main()
{
    char *str = "not Null";
    change(str);
    cout<<"str is " << str;      // ==>str is <null>
}

Java передает "Java-ссылку" на примере значения

public class ValueDemo{

    public void change (String str){
        str = null;
    }

     public static void main(String []args){
        ValueDemo vd = new ValueDemo();
        String str = "not null";
        vd.change(str);
        System.out.println("str is " + str);    // ==> str is not null!!
                                                // Note that if "str" was
                                                // passed-by-reference, it
                                                // WOULD BE NULL after the
                                                // call to change().
     }
}

РЕДАКТИРОВАТЬ

Несколько человек написали комментарии, которые, кажется, указывают, что либо они не смотрят на мои примеры, либо не получают пример c ++. Не уверен, где разъединение, но угадать пример с ++ не ясно. Я выкладываю тот же пример на паскале, потому что думаю, что переход по ссылке выглядит на Паскале чище, но я могу ошибаться. Я мог бы просто запутывать людей больше; Надеюсь нет.

В паскале параметры, передаваемые по ссылке, называются «параметрами вар». В процедуре setToNil ниже обратите внимание на ключевое слово «var», которое предшествует параметру «ptr». Когда указатель передается этой процедуре, он передается по ссылке . Обратите внимание на поведение: когда эта процедура устанавливает для ptr значение nil (это говорит на паскале для NULL), она устанавливает для аргумента значение nil - вы не можете сделать это в Java.

program passByRefDemo;
type 
   iptr = ^integer;
var
   ptr: iptr;

   procedure setToNil(var ptr : iptr);
   begin
       ptr := nil;
   end;

begin
   new(ptr);
   ptr^ := 10;
   setToNil(ptr);
   if (ptr = nil) then
       writeln('ptr seems to be nil');     { ptr should be nil, so this line will run. }
end.

РЕДАКТИРОВАТЬ 2

Некоторые выдержки из «Языка программирования Java» Кена Арнольда, Джеймса Гослинга (парня, который изобрел Java) и Дэвида Холмса, глава 2, раздел 2.6.5

Все параметры в методы передаются «по значению» . Другими словами, значения переменных параметров в методе являются копиями инициатора, указанного в качестве аргументов.

Он продолжает делать то же самое в отношении объектов. , ,

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

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

Язык программирования Java не передает объекты по ссылке; он передает ссылки на объекты по значению . Поскольку две копии одной и той же ссылки ссылаются на один и тот же фактический объект, изменения, внесенные через одну ссылочную переменную, видны через другую. Существует ровно один способ передачи параметров - передача по значению - и это помогает упростить процесс.

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

Я думаю, что разница между этими двумя моделями очень тонкая, и если вы не занимались программированием, где фактически использовали переход по ссылке, легко пропустить, где две модели отличаются.

Я надеюсь, что это решит спор, но, вероятно, не будет.

РЕДАКТИРОВАТЬ 3

Я мог бы быть немного одержим этим постом. Вероятно, потому что я чувствую, что создатели Java непреднамеренно распространяют дезинформацию. Если бы вместо использования слова «ссылка» для указателей они использовали что-то еще, скажем, Dingleberry, не было бы никаких проблем. Вы можете сказать: «Java передает dingleberry по значению, а не по ссылке», и никто не будет смущен.

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

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

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

Передача по ссылке - Копия ссылки отсутствует. Одиночная ссылка совместно используется как вызывающей, так и вызываемой функцией. Любые изменения в ссылке или данных объекта отражаются в области действия вызывающей стороны.

РЕДАКТИРОВАТЬ 4

Я видел посты на эту тему, которые описывают низкоуровневую реализацию передачи параметров в Java, что я считаю замечательным и очень полезным, потому что оно делает абстрактную идею конкретной. Однако для меня вопрос скорее в поведении, описанном в спецификации языка, чем в технической реализации поведения. Это выдержка из спецификации языка Java, раздел 8.4.1 :

Когда метод или конструктор вызывают (§15.12), значения фактических выражений аргумента инициализируют вновь созданные переменные параметра, каждый из объявленного типа, перед выполнением тела метода или конструктора. Идентификатор, который появляется в DeclaratorId, может использоваться как простое имя в теле метода или конструктора для ссылки на формальный параметр.

Это означает, что java создает копию переданных параметров перед выполнением метода. Как и большинство людей , которые изучали компилятор в колледже, я использовал «Книгу дракона» , который составители книга. В главе 1 есть хорошее описание «Call-by-value» и «Call-by-Reference». Описание Call-by-value точно соответствует спецификациям Java.

Еще в 90-е годы, когда я изучал компиляторы, я использовал первое издание книги 1986 года, которое предшествовало Java примерно на 9 или 10 лет. Тем не менее, я только что натолкнулся на копию 2- й редакции 2007 года, в которой на самом деле упоминается Java! Раздел 1.6.6, озаглавленный «Механизмы передачи параметров», описывает передачу параметров довольно красиво. Вот выдержка под заголовком «Call-by-value», в которой упоминается Java:

В вызове по значению фактический параметр оценивается (если это выражение) или копируется (если это переменная). Значение помещается в местоположение, принадлежащее соответствующему формальному параметру вызываемой процедуры. Этот метод используется в C и Java и является распространенным вариантом в C ++, а также в большинстве других языков.

Насколько я знаю, Java знает только вызов по значению. Это означает, что для примитивных типов данных вы будете работать с копией, а для объектов вы будете работать с копией ссылки на объекты. Однако я думаю, что есть некоторые подводные камни; например, это не будет работать:

public static void swap(StringBuffer s1, StringBuffer s2) {
    StringBuffer temp = s1;
    s1 = s2;
    s2 = temp;
}


public static void main(String[] args) {
    StringBuffer s1 = new StringBuffer("Hello");
    StringBuffer s2 = new StringBuffer("World");
    swap(s1, s2);
    System.out.println(s1);
    System.out.println(s2);
}

Это заполнит Hello World, а не World Hello, потому что в функции подкачки вы используете copys, которые не влияют на ссылки в основном. Но если ваши объекты не являются неизменяемыми, вы можете изменить это, например:

public static void appendWorld(StringBuffer s1) {
    s1.append(" World");
}

public static void main(String[] args) {
    StringBuffer s = new StringBuffer("Hello");
    appendWorld(s);
    System.out.println(s);
}

Это заполнит Hello World в командной строке. Если вы измените StringBuffer на String, он выдаст только Hello, потому что String неизменен. Например:

public static void appendWorld(String s){
    s = s+" World";
}

public static void main(String[] args) {
    String s = new String("Hello");
    appendWorld(s);
    System.out.println(s);
}

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

class StringWrapper {
    public String value;

    public StringWrapper(String value) {
        this.value = value;
    }
}

public static void appendWorld(StringWrapper s){
    s.value = s.value +" World";
}

public static void main(String[] args) {
    StringWrapper s = new StringWrapper("Hello");
    appendWorld(s);
    System.out.println(s.value);
}

редактировать: я считаю, что это также причина для использования StringBuffer, когда дело доходит до «добавления» двух строк, потому что вы можете изменить исходный объект, что вы не можете с неизменными объектами, такими как String.

Нет, это не передача по ссылке.

Java передается по значению в соответствии со спецификацией языка Java:

Когда метод или конструктор вызывается (§15.12), значения фактических выражений аргумента инициализируют вновь созданные переменные параметра , каждая из объявленного типа, перед выполнением тела метода или конструктора. Идентификатор, который появляется в DeclaratorId, может использоваться как простое имя в теле метода или конструктора для ссылки на формальный параметр .

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

/ **

Передать по значению

В Java все параметры передаются по значению, т. Е. Назначение аргумента метода не отображается вызывающей стороне.

* /

Пример 1:

public class PassByValueString {
    public static void main(String[] args) {
        new PassByValueString().caller();
    }

    public void caller() {
        String value = "Nikhil";
        boolean valueflag = false;
        String output = method(value, valueflag);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'value' and 'valueflag'
         */
        System.out.println("output : " + output);
        System.out.println("value : " + value);
        System.out.println("valueflag : " + valueflag);

    }

    public String method(String value, boolean valueflag) {
        value = "Anand";
        valueflag = true;
        return "output";
    }
}

Результат

output : output
value : Nikhil
valueflag : false

Пример 2:

/ ** * * Передать по значению * * /

public class PassByValueNewString {
    public static void main(String[] args) {
        new PassByValueNewString().caller();
    }

    public void caller() {
        String value = new String("Nikhil");
        boolean valueflag = false;
        String output = method(value, valueflag);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'value' and 'valueflag'
         */
        System.out.println("output : " + output);
        System.out.println("value : " + value);
        System.out.println("valueflag : " + valueflag);

    }

    public String method(String value, boolean valueflag) {
        value = "Anand";
        valueflag = true;
        return "output";
    }
}

Результат

output : output
value : Nikhil
valueflag : false

Пример 3:

/ ** Этот «Pass By Value» имеет ощущение «Pass By Reference»

Некоторые люди говорят, что примитивные типы и «String» - это «передача по значению», а объекты - «передача по ссылке».

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

* /

public class PassByValueObjectCase1 {

    private class Student {
        int id;
        String name;
        public Student() {
        }
        public Student(int id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Student [id=" + id + ", name=" + name + "]";
        }
    }

    public static void main(String[] args) {
        new PassByValueObjectCase1().caller();
    }

    public void caller() {
        Student student = new Student(10, "Nikhil");
        String output = method(student);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'student'
         */
        System.out.println("output : " + output);
        System.out.println("student : " + student);
    }

    public String method(Student student) {
        student.setName("Anand");
        return "output";
    }
}

Результат

output : output
student : Student [id=10, name=Anand]

Пример 4:

/ **

В дополнение к тому, что было упомянуто в примере 3 (PassByValueObjectCase1.java), мы не можем изменить фактическую ссылку за пределы исходной области. "

Примечание: я не вставляю код для private class Student. Определение класса для Studentтакое же, как в примере 3.

* /

public class PassByValueObjectCase2 {

    public static void main(String[] args) {
        new PassByValueObjectCase2().caller();
    }

    public void caller() {
        // student has the actual reference to a Student object created
        // can we change this actual reference outside the local scope? Let's see
        Student student = new Student(10, "Nikhil");
        String output = method(student);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'student'
         */
        System.out.println("output : " + output);
        System.out.println("student : " + student); // Will it print Nikhil or Anand?
    }

    public String method(Student student) {
        student = new Student(20, "Anand");
        return "output";
    }

}

Результат

output : output
student : Student [id=10, name=Nikhil]

Вы никогда не можете перейти по ссылке в Java, и один из очевидных способов - это когда вы хотите вернуть более одного значения из вызова метода. Рассмотрим следующий фрагмент кода на C ++:

void getValues(int& arg1, int& arg2) {
    arg1 = 1;
    arg2 = 2;
}
void caller() {
    int x;
    int y;
    getValues(x, y);
    cout << "Result: " << x << " " << y << endl;
}

Иногда вы хотите использовать тот же шаблон в Java, но не можете; по крайней мере, не напрямую. Вместо этого вы можете сделать что-то вроде этого:

void getValues(int[] arg1, int[] arg2) {
    arg1[0] = 1;
    arg2[0] = 2;
}
void caller() {
    int[] x = new int[1];
    int[] y = new int[1];
    getValues(x, y);
    System.out.println("Result: " + x[0] + " " + y[0]);
}

Как было объяснено в предыдущих ответах, в Java вы передаете указатель на массив как значение в getValues. Этого достаточно, потому что метод затем модифицирует элемент массива, и по соглашению вы ожидаете, что элемент 0 будет содержать возвращаемое значение. Очевидно, что вы можете сделать это другими способами, такими как структурирование вашего кода, так что в этом нет необходимости, или создание класса, который может содержать возвращаемое значение или разрешить его установку. Но простой шаблон, доступный вам в C ++ выше, недоступен в Java.

Я думал, что добавлю этот ответ, чтобы добавить больше деталей из Спецификаций.

Во-первых, в чем разница между передачей по ссылке и передачей по значению?

Передача по ссылке означает, что параметр вызываемых функций будет таким же, как переданный аргумент вызывающего (не значение, а идентификатор - сама переменная).

Передача по значению означает, что параметр вызываемых функций будет копией переданного аргумента вызывающей стороны.

Или из википедии, на тему передачи по ссылке

При оценке по ссылке (также называемой передачей по ссылке) функция получает неявную ссылку на переменную, используемую в качестве аргумента, а не на копию ее значения. Как правило, это означает, что функция может модифицировать (т.е. назначать) переменную, используемую в качестве аргумента - то, что увидит ее вызывающая сторона.

И на предмет передачи по стоимости

В вызове по значению выражение аргумента оценивается, и результирующее значение привязывается к соответствующей переменной в функции [...]. Если функция или процедура может назначать значения своим параметрам, назначается только ее локальная копия [...].

Во-вторых, нам нужно знать, что Java использует в своих вызовах методов. В языке спецификация Java состояния

Когда метод или конструктор вызывается (§15.12), значения фактических выражений аргумента инициализируют вновь созданные переменные параметра , каждая из объявленного типа, перед выполнением тела метода или конструктора.

Таким образом, он присваивает (или связывает) значение аргумента соответствующей переменной параметра.

Какова ценность аргумента?

Давайте рассмотрим ссылочные типы, в Java Virtual Machine Specification состояния

Существует три типа ссылочных типов : типы классов, типы массивов и типы интерфейсов. Их значения являются ссылками на динамически создаваемые экземпляры классов, массивы или экземпляры классов или массивы, которые реализуют интерфейсы соответственно.

Спецификация языка Java также говорится ,

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

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

Так

public void method (String param) {}
...
String var = new String("ref");
method(var);
method(var.toString());
method(new String("ref"));

все связывают значение ссылки на Stringэкземпляр для вновь созданного параметра метода, в param. Это именно то, что описывает определение передачи по значению. Таким образом, Java передается по значению .

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

Как правило, это означает, что функция может модифицировать (т.е. назначать) переменную, используемую в качестве аргумента - то, что увидит ее вызывающая сторона.

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

Примитивные значения также определены в Спецификации виртуальной машины Java, здесь . Значением типа является соответствующее целочисленное значение или значение с плавающей запятой, кодированное соответствующим образом (8, 16, 32, 64 и т. Д. Биты).

В Java только ссылки передаются и передаются по значению:

Все аргументы Java передаются по значению (ссылка используется при использовании метода):

В случае примитивных типов поведение Java простое: значение копируется в другой экземпляр примитивного типа.

В случае объектов это тоже самое: переменные объекта - это указатели (сегменты), содержащие только адрес объекта, который был создан с использованием ключевого слова «new», и копируются как примитивные типы.

Поведение может отличаться от примитивных типов: поскольку скопированная переменная объекта содержит один и тот же адрес (для одного и того же объекта). Содержимое / члены объекта все еще могут быть изменены внутри метода, а затем и доступ снаружи, создавая иллюзию, что сам (содержащий) Объект был передан по ссылке.

«Строковые» объекты кажутся хорошим контрпримером к городской легенде о том, что «объекты передаются по ссылке»:

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

String Object, содержит символы в массиве, объявленном как final, который нельзя изменить. Только адрес объекта может быть заменен другим, используя «новый». Использование «new» для обновления переменной не позволит получить доступ к объекту извне, поскольку переменная изначально была передана по значению и скопирована.

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

Как уже упоминали многие люди, Java всегда передается по значению

Вот еще один пример, который поможет вам понять разницу ( классический пример обмена ):

public class Test {
  public static void main(String[] args) {
    Integer a = new Integer(2);
    Integer b = new Integer(3);
    System.out.println("Before: a = " + a + ", b = " + b);
    swap(a,b);
    System.out.println("After: a = " + a + ", b = " + b);
  }

  public static swap(Integer iA, Integer iB) {
    Integer tmp = iA;
    iA = iB;
    iB = tmp;
  }
}

Печать:

До: а = 2, б = 3
После: а = 2, б = 3

Это происходит потому, что iA и iB являются новыми локальными ссылочными переменными, которые имеют одинаковое значение переданных ссылок (они указывают на a и b соответственно). Таким образом, попытка изменить ссылки iA или iB изменится только в локальной области, а не вне этого метода.

У Java есть только передача по значению. Очень простой пример, чтобы подтвердить это.

public void test() {
    MyClass obj = null;
    init(obj);
    //After calling init method, obj still points to null
    //this is because obj is passed as value and not as reference.
}
private void init(MyClass objVar) {
    objVar = new MyClass();
}

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

public class PassByCopy{
    public static void changeName(Dog d){
        d.name = "Fido";
    }
    public static void main(String[] args){
        Dog d = new Dog("Maxx");
        System.out.println("name= "+ d.name);
        changeName(d);
        System.out.println("name= "+ d.name);
    }
}
class Dog{
    public String name;
    public Dog(String s){
        this.name = s;
    }
}

вывод Java PassByCopy:

имя = макс
имя = фидо

Примитивные классы-обертки и строки неизменны, поэтому любой пример, использующий эти типы, не будет работать так же, как другие типы / объекты.

В отличие от некоторых других языков, Java не позволяет выбирать между передачей по значению и передачей по ссылке - все аргументы передаются по значению. Вызов метода может передавать в метод два типа значений - копии примитивных значений (например, значений типа int и double) и копии ссылок на объекты.

Когда метод изменяет параметр типа примитива, изменения параметра не влияют на исходное значение аргумента в вызывающем методе.

Когда дело доходит до объектов, сами объекты не могут быть переданы в методы. Таким образом, мы передаем ссылку (адрес) объекта. Мы можем манипулировать исходным объектом, используя эту ссылку.

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

Account account1 = new Account();

«Account account1» - это тип и имя ссылочной переменной, «=» - оператор присваивания, «new» запрашивает необходимый объем пространства в системе. Конструктор справа от ключевого слова new, который создает объект, неявно вызывается ключевым словом new. Адрес созданного объекта (результат правильного значения, которое является выражением, называемым «выражением создания экземпляра класса») присваивается левому значению (которое является ссылочной переменной с указанным именем и типом) с помощью оператора присвоения.

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

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

На рисунке ниже вы можете видеть, что у нас есть две ссылочные переменные (они называются указателями в C / C ++, и я думаю, что этот термин облегчает понимание этой функции.) В методе main. Примитивные и эталонные переменные хранятся в памяти стека (левая сторона на изображениях ниже). ссылочные переменные array1 и array2 "точка" (как ее называют программисты C / C ++) или ссылки на массивы a и b соответственно, которые являются объектами (значения, которые эти ссылочные переменные содержат адреса объектов) в динамической памяти (справа на изображениях ниже) ,

Если мы передаем значение ссылочной переменной array1 в качестве аргумента методу reverseArray, в методе создается ссылочная переменная, и эта ссылочная переменная начинает указывать на тот же массив (a).

public class Test
{
    public static void reverseArray(int[] array1)
    {
        // ...
    }

    public static void main(String[] args)
    {
        int[] array1 = { 1, 10, -7 };
        int[] array2 = { 5, -190, 0 };

        reverseArray(array1);
    }
}

Итак, если мы скажем

array1[0] = 5;

в методе reverseArray он внесет изменение в массив a.

У нас есть другая ссылочная переменная в методе reverseArray (array2), которая указывает на массив c. Если бы мы сказали

array1 = array2;

в методе reverseArray ссылочная переменная array1 в методе reverseArray перестает указывать на массив a и начинает указывать на массив c (пунктирная линия на втором изображении).

Если мы возвращаем значение ссылочной переменной array2 в качестве возвращаемого значения метода reverseArray и присваиваем это значение ссылочной переменной array1 в main методе, array1 в main начнет указывать на массив c.

Итак, давайте напишем все, что мы сделали сразу.

public class Test
{
    public static int[] reverseArray(int[] array1)
    {
        int[] array2 = { -7, 0, -1 };

        array1[0] = 5; // array a becomes 5, 10, -7

        array1 = array2; /* array1 of reverseArray starts
          pointing to c instead of a (not shown in image below) */
        return array2;
    }

    public static void main(String[] args)
    {
        int[] array1 = { 1, 10, -7 };
        int[] array2 = { 5, -190, 0 };

        array1 = reverseArray(array1); /* array1 of 
         main starts pointing to c instead of a */
    }
}

И теперь, когда метод reverseArray завершен, его ссылочные переменные (array1 и array2) исчезли. Это означает, что теперь у нас есть только две ссылочные переменные в основном методе array1 и array2, которые указывают на массивы c и b соответственно. Ссылочная переменная не указывает на объект (массив) a. Так что он имеет право на сборку мусора.

Вы также можете присвоить значение array2 в main для array1. массив1 начнет указывать на б.

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

Ява также упоминается . Вот краткое резюме:

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

Короче говоря, у объектов Java есть некоторые очень специфические свойства.

В общем, Java , имеет примитивные типы ( int, bool, char, doubleи т.д.), которые передаются непосредственно по значению. Тогда у Java есть объекты (все, что происходит от java.lang.Object). Объекты на самом деле всегда обрабатываются с помощью ссылки (ссылка - это указатель, который вы не можете коснуться). Это означает, что, по сути, объекты передаются по ссылке, так как ссылки обычно не интересны. Это, однако, означает, что вы не можете изменить объект, на который указывает объект, так как сама ссылка передается по значению.

Это звучит странно и сбивает с толку? Давайте рассмотрим, как C реализует передачу по ссылке и передачу по значению. В С соглашением по умолчанию является передача по значению. void foo(int x)передает int по значению. void foo(int *x)это функция , которая не желает , чтобы int a, но указатель на междунар: foo(&a). Можно использовать это с &оператором для передачи адреса переменной.

Отнесите это на C ++, и у нас есть ссылки. Ссылки в основном (в этом контексте) являются синтаксическим сахаром, который скрывает указатель части уравнения: void foo(int &x)вызывается foo(a), когда сам компилятор знает, что это ссылка, и адрес не-ссылки aдолжен быть передан. В Java все переменные, ссылающиеся на объекты, на самом деле относятся к ссылочному типу, фактически вызывая вызов по ссылке для большинства целей и задач без детального контроля (и сложности), предоставляемого, например, C ++.