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

Важнейшее краеугольное знание должно быть цитируемым,

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

Java: Руководство для начинающих, шестое издание, Герберт Шильдт

Взгляните на этот код. Этот код не будет генерировать _1 _... Он напечатает "Vinay"

public class Main {
    public static void main(String[] args) {
        String temp = "Vinay";
        print(temp);
        System.err.println(temp);
    }

    private static void print(String temp) {
        temp = null;
    }
}

Если Java передается по ссылке, тогда она должна была выбросить NullPointerException, поскольку для ссылки установлено значение Null.

Я вижу, что все ответы содержат одно и то же: передать по значению. Однако недавнее сообщение Брайана Гетца о проекте Valhalla на самом деле отвечает на это иначе:

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

Вы можете прочитать больше здесь: Штат Валгалла. Раздел 2. Языковая модель

Изменить: Брайан Гетц - архитектор языка Java, возглавляющий такие проекты, как Project Valhalla и Project Amber.

Edit-2020-12-08: обновлено Штат Валгалла

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

Теперь люди любят бесконечно спорить о том, является ли «передача по ссылке» правильным способом описания того, что Java et al. на самом деле делаю. Дело вот в чем:

1. Передача объекта не копирует объект.
2. У объекта, переданного в функцию, могут быть изменены ее члены.
3. Примитивное значение, переданное функции, не может быть изменено функцией. Сделана копия.

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

- Брайан Би - Какие языки программирования передаются по ссылке?

Короче:

1. Непримитивы: Java передает значение ссылки.
2. Примитивы: просто ценность.

Конец.

(2) слишком просто. Теперь, если вы хотите подумать о том, что подразумевает (1), представьте, что у вас есть класс Apple:

class Apple {
    private double weight;
    public Apple(double weight) {
        this.weight = weight;
    }
    // getters and setters ...

}

затем, когда вы передаете экземпляр этого класса основному методу:

class Main {
    public static void main(String[] args) {
        Apple apple = new Apple(3.14);
        transmogrify(apple);
        System.out.println(apple.getWeight()+ " the goose drank wine...";

    }

    private static void transmogrify(Apple apple) {
        // does something with apple ...
        apple.setWeight(apple.getWeight()+0.55);
    }
}

о ... но вы, наверное, это знаете, вас интересует, что происходит, когда вы делаете что-то вроде этого:

class Main {
    public static void main(String[] args) {
        Apple apple = new Apple(3.14);
        transmogrify(apple);
        System.out.println("Who ate my: "+apple.getWeight()); // will it still be 3.14? 

    }

    private static void transmogrify(Apple apple) {
        // assign a new apple to the reference passed...
        apple = new Apple(2.71);
    }


}

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

Все аргументы передаются по значению.

Вызов метода может передавать два types of values методу

• копии примитивных значений (например, значения типа int и double)
• копии ссылок на объекты.

Objects themselves cannot be passed to methods. Когда метод изменяет параметр примитивного типа, изменения параметра не влияют на исходное значение аргумента в вызывающем методе.

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

Ссылки: Java ™ How To Program (Early Objects), Tenth Издание

Простой тест для проверки того, поддерживает ли язык передачу по ссылке, - это просто написание традиционного свопа. Можете ли вы написать традиционный метод / функцию swap (a, b) на Java?

Традиционный метод или функция подкачки принимает два аргумента и меняет их местами, так что переменные, переданные в функцию, изменяются вне функции. Его основная структура выглядит как

(Не-Java) Базовая структура функции подкачки

swap(Type arg1, Type arg2) {
    Type temp = arg1;
    arg1 = arg2;
    arg2 = temp;
}

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

Type var1 = ...;
Type var2 = ...;
swap(var1,var2);

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

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

• передается по значению: у вызывающего и вызываемого есть две независимые переменные с одинаковым значением.

• Java uses pass by value
  • When passing primitive data, it copies the value of primitive data type.
  • При передаче объекта он копирует адрес объекта и передает переменную метода вызываемого объекта.

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

public class PassByValuePrimitive {
    public static void main(String[] args) {
        int i=5;
        System.out.println(i);  //prints 5
        change(i);
        System.out.println(i);  //prints 5
    }


    private static void change(int i) {
        System.out.println(i);  //prints 5
        i=10;
        System.out.println(i); //prints 10

    }
}

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

public class PassByValueObject {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("prem");
        list.add("raj");
        new PassByValueObject().change(list);
        System.out.println(list); // prints [prem, raj, ram]

    }


    private  void change(List list) {
        System.out.println(list.get(0)); // prem
        list.add("ram");
        list=null;
        System.out.println(list.add("bheem")); //gets NullPointerException
    }
}

Java передается по значению.

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

class Test    {

public static void main (String[] args) throws java.lang.Exception
{
    // Primitive type
    System.out.println("Primitve:");
    int a = 5;
    primitiveFunc(a);
    System.out.println("Three: " + a);    //5

    //Object
    System.out.println("Object:");
    DummyObject dummyObject = new DummyObject();
    System.out.println("One: " + dummyObject.getObj());    //555
    objectFunc(dummyObject);
    System.out.println("Four: " + dummyObject.getObj());    //666 (555 if line in method uncommented.)

}

private static void primitiveFunc(int b)    {
    System.out.println("One: " + b);    //5
    b = 10;
    System.out.println("Two:" + b);    //10
}

private static void objectFunc(DummyObject b)   {
    System.out.println("Two: " + b.getObj());    //555
    //b = new DummyObject();
    b.setObj(666);
    System.out.println("Three:" + b.getObj());    //666
}

}

class DummyObject   {
    private int obj = 555;
    public int getObj() { return obj; }
    public void setObj(int num) { obj = num; }
}

Если строка b = new DummyObject() раскомментирована, изменения, сделанные после этого, будут внесены в новый объект, новый экземпляр. Следовательно, это не отражается на месте, откуда вызывается метод. Однако в противном случае изменение отражается, поскольку изменения производятся только на «ссылке» объекта, то есть - b указывает на тот же dummyObject.

Иллюстрации в одном из ответов в этой теме (https://stackoverflow.com/a/12429953/4233180) могут помочь получить более глубокое понимание.

PT 1: Объявления о недвижимости

На 1234 Main St сейчас припаркован синий Tiny House площадью 120 кв. Футов с ухоженным газоном и клумбой перед домом.

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

Назовем этого Риэлтор Боб. Привет боб.

Боб постоянно обновляет свой Листинг, который он называет tinyHouseAt1234Main, с помощью веб-камеры, которая позволяет ему отмечать любые изменения в реальном доме в реальном времени. Он также ведет учет того, сколько людей спрашивали о листинге. Целое число Боба viewTally для дома сегодня составляет 42.

Когда кому-то нужна информация о синем Крошечном домике на Мейн-стрит, 1234, они спрашивают Боба.

Боб просматривает свой Листинг tinyHouseAt1234Main и рассказывает им все - цвет, красивый газон, кровать-чердак, компостный туалет и т. Д. Затем он добавляет их запрос к своему viewTally. Однако он не сообщает им настоящий физический адрес, потому что фирма Боба специализируется на крошечных домиках, которые можно переместить в любое время. Итого сейчас 43.

В другой фирме риэлторы могут прямо указать в своем листинге дом по адресу 1234 Main St, обозначив это небольшим * рядом с ним, потому что они в основном имеют дело с домами, которые редко когда-либо переезжают (хотя, по-видимому, для этого есть причины). Фирма Боба этим не занимается.

Теперь, конечно, Боб физически не идет и не ставит настоящий дом на грузовик, чтобы показать его клиентам напрямую - это было бы непрактично и нелепой тратой ресурсов. Передать полную копию его ведомости учета - одно дело, но постоянно обходить весь дом - дорого и нелепо.

(Кроме того: фирма Боба также не печатает на 3D-принтере новые и уникальные копии указанного дома каждый раз, когда кто-то спрашивает об этом. Это то, что делают выскочка, одноименная веб-фирма и ее дочерние компании - это дорого и медленнее, и люди часто путают две фирмы, но они все равно довольно популярны).

В некоторых других, более старых фирмах, расположенных ближе к морю, такого риэлтора, как Боб, может даже не существовать для управления листингами. Вместо этого клиенты могут проконсультироваться с Rolodex Annie (для краткости &), чтобы узнать прямой адрес дома. Вместо того, чтобы зачитывать данные о доме из списка, как это делает Боб, клиенты вместо этого получают адрес дома от Энни (&) и идут прямо на 1234 Main St, иногда не имея представления, что они могут там найти.

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

Что ж, человек с этой информацией - Боб, поэтому клиент просит Боба вызвать службу и отправить ей копию листинга.

jobKillingAutomatedListingService(Listing tinyHouseAt1234Main, int viewTally) Боб отправляет ...

Служба со своей стороны называет этот Листинг houseToLookAt, но на самом деле то, что он получает, является точной копией листинга Боба с точно такими же ЗНАЧЕНИЯМИ в нем, которые относятся к дому по адресу 1234 Main St.

Эта новая служба также имеет собственный внутренний подсчет количества людей, просмотревших объявление. Служба принимает подсчет Боба из профессиональной вежливости, но на самом деле это не заботит и все равно полностью перезаписывает его собственной локальной копией. Сегодняшний счет - 1, а Бобу все еще 43.

Агентства по продаже недвижимости называют это передачей по значению, поскольку Боб передает текущее значение своего viewTally и своего Листинга tinyHouseAt1234Main. На самом деле он не проходит через весь физический дом, потому что это непрактично. Он также не передает реальный физический адрес, как это сделала бы Энни (&).

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

ПТ II: Когда все становится запутанным и опасным ...

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

После получения объекта Listing, он позволяет клиентам фактически перекрасить НАСТОЯЩИЙ дом на 1234 Main St, используя удаленный флот роботов-дронов! Это позволяет клиентам управлять роботом-бульдозером, чтобы ДЕЙСТВИТЕЛЬНО выкопать клумбу! Это безумие!!!

Служба также позволяет клиентам полностью перенаправить houseToLookAt в другой дом по другому адресу, без участия Боба или его листинга. Внезапно они могли смотреть на улицу Вязов 4321, которая не имеет никакого отношения к списку Боба (к счастью, они больше не могут причинить ущерб).

Боб наблюдает за всем этим по своей веб-камере в реальном времени. Смирившись с тяжелой работой своей единственной должностной обязанности, он рассказывает клиентам о новой уродливой покраске и внезапном отсутствии обуздания. В конце концов, его листинг все еще находится на Мейн-стрит, 1234. Новая служба houseToLookAt не могла этого изменить. Боб сообщает подробности своего tinyHouseAt1234Main точно и послушно, как всегда, пока его не уволят или дом не будет полностью разрушен Ничто.

На самом деле единственное, что служба НЕ МОЖЕТ сделать со своей houseToLookAt копией исходного списка Боба, это изменить адрес с 1234 Main St. . Листинг Боба по-прежнему всегда указывает на 1234 Main St, чего бы он ни стоил. Он, как всегда, передает его текущее значение.

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

Похоже на своего рода придирчивый семантический аргумент, если вас обычно волнует состояние дома в листинге, который копируется и передается, верно?

Я имею в виду, если вы занимались тем, что собирали дома и физически перемещали их по другим адресам (не например, мобильные или крошечные дома, где это своего рода ожидаемая функция платформы), или вы обращались, переименовывали и перетасовывали все окрестностей вроде какого-то низкоуровневого сумасшедшего, играющего в богов, ТОГДА, возможно, вас больше заботит передача этих конкретных адресных ссылок, а не просто копий последних значений деталей дома ...

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

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

Это означает:

• Вы можете изменить значение myObject внутри функции
• Но вы не можете изменить то, на что myObject ссылается внутри функции, потому что point не myObject
• Помните, что и point, и myObject являются ссылками, разными ссылками, однако эти ссылки указывают на одну и ту же new Point(0,0)

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

• pass by value в Java НЕ РАВНО pass by value в C ++, хотя это звучит так, вероятно, поэтому возникает путаница.

Разбивая это:

• pass by value в C ++ означает передачу значения объекта (если объект), буквально копию объекта
• pass by value в Java означает передачу значения адреса объекта (если объект), а не на самом деле значения (копии) объекта, например C ++
• По pass by value в Java, работа с объектом (например, myObj.setName("new")) внутри функции оказывает влияние на объект вне функции; by pass by value в C ++, он не имеет НИКАКИХ эффектов на внешнее.
• Однако, согласно pass by reference в C ++, работа с объектом в функции ДЕЙСТВИТЕЛЬНО оказывает влияние на внешний объект! Подобно (просто похоже, не то же самое) на pass by value в Java, не так ли? .. и люди всегда повторяют: в Java нет передачи по ссылке, = ›BOOM , начинается путаница ...

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

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

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

Хорошее описание обоих можно найти здесь.

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

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

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

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

И нет, специальный синтаксис C ++ «передача по ссылке» не является исключительным определением передачи по ссылке. Это чисто удобный синтаксис, предназначенный для того, чтобы вам не нужно было использовать синтаксис указателя после передачи указателя. Он все еще передает указатель, компилятор просто скрывает от вас этот факт. Он также по-прежнему передает этот указатель BY VALUE, компилятор просто скрывает это от вас.

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

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

Пытаясь добавить к этому еще больше, я подумал, что включу в эту тему раздел «Учебное пособие SCJP». Это из руководства, предназначенного для прохождения теста Sun / Oracle на поведение Java, так что это хороший источник для этого обсуждения.

Передача переменных в методы (цель 7.3)

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

Можно объявить методы, принимающие примитивы и / или ссылки на объекты. Вам необходимо знать, как (или если) вызывающая переменная может быть затронута вызываемым методом. Разница между ссылкой на объект и примитивными переменными при передаче в методы огромна и важна. Чтобы понять этот раздел, вам нужно хорошо разбираться в разделе заданий, описанном в первой части этой главы.

Передача переменных ссылки на объект

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

В этом примере мы будем использовать класс Dimension из пакета java.awt:

1. import java.awt.Dimension;
2. class ReferenceTest {
3.     public static void main (String [] args) {
4.         Dimension d = new Dimension(5,10);
5.         ReferenceTest rt = new ReferenceTest();
6.         System.out.println("Before modify() d.height = " + d.height);
7.         rt.modify(d);
8.         System.out.println("After modify() d.height = "
9.     }
10.
11.
12.
13.   }
14. }

Когда мы запускаем этот класс, мы видим, что метод modify () действительно смог изменить исходный (и единственный) объект Dimension, созданный в строке 4.

C:\Java Projects\Reference>java ReferenceTest
Before modify() d.height = 10
dim = 11
After modify() d.height = 11

Обратите внимание, когда объект Dimension в строке 4 передается методу modify (), любые изменения объекта, происходящие внутри метода, вносятся в объект, ссылка на который была передана. В предыдущем примере ссылочные переменные d и dim указывают на один и тот же объект.

Использует ли Java семантику передачи по значению?

Если Java передает объекты, передавая вместо этого ссылочную переменную, означает ли это, что Java использует передачу по ссылке для объектов? Не совсем, хотя вы часто слышите и читаете, что это так. Java фактически является передачей по значению для всех переменных, работающих в одной виртуальной машине. Передача по значению означает передачу по значению переменной. А это означает передачу за копией переменной! (Опять это слово копирует!)

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

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

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

        void bar() {
           Foo f = new Foo();
           doStuff(f);
        }
        void doStuff(Foo g) {
           g.setName("Boo");
           g = new Foo();
        }

переназначение g не переназначает f! В конце метода bar () были созданы два объекта Foo, на один ссылается локальная переменная f, а на один - локальная (аргументная) переменная g. Поскольку метод doStuff () имеет копию ссылочной переменной, у него есть способ перейти к исходному объекту Foo, например, вызвать метод setName (). Но у метода doStuff () нет способа добраться до ссылочной переменной f. Таким образом, doStuff () может изменять значения в объекте, на который ссылается f, но doStuff () не может изменять фактическое содержимое (битовый шаблон) f. Другими словами, doStuff () может изменить состояние объекта, на который ссылается f, но не может заставить f ссылаться на другой объект!

Передача примитивных переменных

Давайте посмотрим, что происходит, когда примитивная переменная передается в метод:

class ReferenceTest {
    public static void main (String [] args) {
      int a = 1;
      ReferenceTest rt = new ReferenceTest();
      System.out.println("Before modify() a = " + a);
      rt.modify(a);
      System.out.println("After modify() a = " + a);
    }
    void modify(int number) {
      number = number + 1;
      System.out.println("number = " + number);
    }
}

В этой простой программе переменная a передается методу с именем modify (), который увеличивает значение переменной на 1. Результат выглядит следующим образом:

  Before modify() a = 1
  number = 2
  After modify() a = 1

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

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

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

class Example
{
    public static void test (Cat ref)
    {
        // 3 - <ref> is a copy of the reference <a>
        // both currently reference Grumpy
        System.out.println(ref.getName());

        // 4 - now <ref> references a new <Cat> object named "Nyan"
        ref = new Cat("Nyan");

        // 5 - this should print "Nyan"
        System.out.println( ref.getName() );
    }

    public static void main (String [] args)
    {
        // 1 - a is a <Cat> reference that references a Cat object in memory with name "Grumpy"
        Cat a = new Cat("Grumpy");

        // 2 - call to function test which takes a <Cat> reference
        test (a);

        // 6 - function call ends, and <ref> life-time ends
        // "Nyan" object has no references and the Garbage
        // Collector will remove it from memory when invoked

        // 7 - this should print "Grumpy"
        System.out.println(a.getName());
    }
}

Все передается по стоимости. Примитивы и ссылки на объекты. Но объекты можно изменять, если это позволяет их интерфейс.

Когда вы передаете объект методу, вы передаете ссылку, и объект может быть изменен реализацией метода.

void bithday(Person p) {
    p.age++;
}

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

void renameToJon(Person p) { 
    p = new Person("Jon"); // this will not work
}

jack = new Person("Jack");
renameToJon(jack);
sysout(jack); // jack is unchanged

По сути, «p» является ссылкой (указателем на объект) и не может быть изменена.

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

Напомним, все передается по значению.

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

public static void dummyIncrease(int[] x, int y)
{
    x[0]++;
    y++;
}
public static void main(String[] args)
{
    int[] arr = {3, 4, 5};
    int b = 1;
    dummyIncrease(arr, b);
    // arr[0] is 4, but b is still 1
}

main()
  arr +---+       +---+---+---+
      | # | ----> | 3 | 4 | 5 |
      +---+       +---+---+---+
  b   +---+             ^
      | 1 |             | 
      +---+             |
                        |
dummyIncrease()         |
  x   +---+             |
      | # | ------------+
      +---+      
  y   +---+ 
      | 1 | 
      +---+ 

Кратчайший ответ :)

• В Java есть передача по значению (и передача по ссылке по значению).
• В C # также есть передача по ссылке

В C # это достигается с помощью ключевых слов out и ref.

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

Далее следует пример передачи по ссылке (C #). Эта функция не существует в java.

class Example
{
    static void InitArray(out int[] arr)
    {
        arr = new int[5] { 1, 2, 3, 4, 5 };
    }

    static void Main()
    {
        int[] someArray;
        InitArray(out someArray);

        // This is true !
        boolean isTrue = (someArray[0] == 1);
    }
}

См. Также: библиотека MSDN ( C #): передача массивов по ссылке и out

См. Также: библиотека MSDN (C #): передача по значению и по ссылке

Простая программа

import java.io.*;
class Aclass
{
    public int a;
}
public class test
{
    public static void foo_obj(Aclass obj)
    {
        obj.a=5;
    }
    public static void foo_int(int a)
    {
        a=3;
    }
    public static void main(String args[])
    {
        //test passing an object
        Aclass ob = new Aclass();
        ob.a=0;
        foo_obj(ob);
        System.out.println(ob.a);//prints 5

        //test passing an integer
        int i=0;
        foo_int(i);
        System.out.println(i);//prints 0
    }
}

С точки зрения программиста C / C ++, java использует передачу по значению, поэтому для примитивных типов данных (int, char и т. Д.) Изменения в функции не отражаются в вызывающей функции. Но когда вы передаете объект и в функции меняете его члены-данные или вызываете функции-члены, которые могут изменять состояние объекта, вызывающая функция получит изменения.

Есть очень простой способ понять это. Давайте возьмем C ++ по ссылке.

#include <iostream>
using namespace std;

class Foo {
    private:
        int x;
    public:
        Foo(int val) {x = val;}
        void foo()
        {
            cout<<x<<endl;
        }
};

void bar(Foo& ref)
{
    ref.foo();
    ref = *(new Foo(99));
    ref.foo();
}

int main()
{
   Foo f = Foo(1);
   f.foo();
   bar(f);
   f.foo();

   return 0;
}

Что в итоге?

1
1
99
99

Итак, после того, как bar () присвоил новое значение переданной «ссылке», он фактически изменил значение, которое было передано из самой main, объясняя последний вызов f.foo () из основной печати 99.

Теперь давайте посмотрим, что говорит java.

public class Ref {

    private static class Foo {
        private int x;

        private Foo(int x) {
            this.x = x;
        }

        private void foo() {
            System.out.println(x);
        }
    }

    private static void bar(Foo f) {
        f.foo();
        f = new Foo(99);
        f.foo();
    }

    public static void main(String[] args) {
        Foo f = new Foo(1);
        System.out.println(f.x);
        bar(f);
        System.out.println(f.x);
    }

}

Он говорит:

1
1
99
1

Вуаля, ссылка на Foo в main, которая была передана в bar, все еще не изменилась!

Этот пример ясно показывает, что java - это не то же самое, что C ++, когда мы говорим «передать по ссылке». По сути, java передает «ссылки» как «значения» функциям, то есть java передается по значению.

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

package com.asok.cop.example.task;
public class Example {
    int data = 50;

    void change(int data) {
        data = data + 100;// changes will be in the local variable 
        System.out.println("after add " + data);
        }

    public static void main(String args[]) {
        Example op = new Example();
        System.out.println("before change " + op.data);
        op.change(500);
        System.out.println("after change " + op.data);
    }
}

Выход:

before change 50
after add 600
after change 50

как Майкл говорит в комментариях:

объекты по-прежнему передаются по значению, хотя операции с ними ведут себя как передача по ссылке. Учтите, что void changePerson(Person person){ person = new Person(); } ссылка вызывающего абонента на объект person останется неизменной. Сами объекты передаются по значению, но их члены могут быть затронуты изменениями. Чтобы быть истинной передачей по ссылке, мы должны иметь возможность переназначить аргумент новому объекту и отразить изменение в вызывающей стороне.

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

Возьмем, к примеру, метод badSwap ():

public void badSwap(int var1, int var2)
{
  int temp = var1;
  var1 = var2;
  var2 = temp;
}

Когда badSwap () возвращается, переменные, переданные в качестве аргументов, по-прежнему сохраняют свои исходные значения. Метод также не сработает, если мы изменим тип аргументов с int на Object, поскольку Java также передает ссылки на объекты по значению. Теперь вот где это становится сложным:

public 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("X: " + pnt1.x + " Y: " +pnt1.y); 
  System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);
  System.out.println(" ");
  tricky(pnt1,pnt2);
  System.out.println("X: " + pnt1.x + " Y:" + pnt1.y); 
  System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);  
}

Если мы выполним этот метод main (), мы увидим следующий результат:

X: 0 Y: 0
X: 0 Y: 0
X: 100 Y: 100
X: 0 Y: 0

Метод успешно изменяет значение pnt1, даже если оно передается по значению; однако поменять местами pnt1 и pnt2 не удается! Это главный источник путаницы. В методе main () pnt1 и pnt2 - это не что иное, как ссылки на объекты. Когда вы передаете pnt1 и pnt2 методу tricky (), Java передает ссылки по значению, как и любой другой параметр. Это означает, что ссылки, переданные в метод, на самом деле являются копиями исходных ссылок. На рисунке 1 ниже показаны две ссылки, указывающие на один и тот же объект после того, как Java передает объект методу.

Рисунок 1. После передачи методу объект будет иметь как минимум две ссылки.

Java копирует и передает ссылку по значению, а не по объекту. Таким образом, манипуляции с методами изменят объекты, поскольку ссылки указывают на исходные объекты. Но поскольку ссылки являются копиями, обмен не удастся. Обмен ссылками на методы, но не на исходные ссылки. К сожалению, после вызова метода у вас остаются только исходные ссылки без замены. Чтобы замена прошла успешно вне вызова метода, нам нужно поменять местами исходные ссылки, а не копии.

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

Пожалуйста, обратитесь к приведенному ниже примеру,

public class ObjectReferenceExample {

    public static void main(String... doYourBest) {
            Student student = new Student();
            transformIntoHomer(student);
            System.out.println(student.name);
    }

    static void transformIntoDuleepa(Student student) {
            student.name = "Duleepa";
    }
}
class Student {
    String name;
}

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

Мистер @Scott Stanchfield написал отличный ответ. Вот класс, который вы хотели бы проверить, что он имел в виду:

public class Dog {

    String dog ;
    static int x_static;
    int y_not_static;

    public String getName()
    {
        return this.dog;
    }

    public Dog(String dog)
    {
        this.dog = dog;
    }

    public void setName(String name)
    {
        this.dog = name;
    }

    public static void foo(Dog someDog)
    {
        x_static = 1;
        // y_not_static = 2;  // not possible !!
        someDog.setName("Max");     // AAA
        someDog = new Dog("Fifi");  // BBB
        someDog.setName("Rowlf");   // CCC
    }

    public static void main(String args[])
    {
        Dog myDog = new Dog("Rover");
        foo(myDog);
        System.out.println(myDog.getName());
    }
}

Итак, мы передаем из main () собаку по имени Rover, затем мы назначаем новый адрес указателю, который мы передали, но в конце имя собаки не Rover, и не Fifi, и, конечно, не Rowlf, но Max.

Разберитесь в двух шагах:

Вы не можете изменить ссылку на сам объект, но можете работать с этим переданным параметром как ссылкой на объект.

Если вы хотите изменить значение за ссылкой, вы только объявите новую переменную в стеке с тем же именем 'd'. Посмотрите на ссылки со знаком @, и вы обнаружите, что ссылка была изменена.

public static void foo(Dog d) {
  d.Name = "belly";
  System.out.println(d); //Reference: Dog@1540e19d

  d = new Dog("wuffwuff");
  System.out.println(d); //Dog@677327b6
}
public static void main(String[] args) throws Exception{
  Dog lisa = new Dog("Lisa");
  foo(lisa);
  System.out.println(lisa.Name); //belly
}

Я попытался упростить приведенные выше примеры, сохранив только суть проблемы. Позвольте мне представить это как историю, которую легко запомнить и правильно применить. История гласит: у вас есть домашняя собака Джимми, хвост которой составляет 12 дюймов. Вы оставляете его ветеринару на несколько недель, пока едете за границу.

Ветеринару не нравится длинный хвост Джимми, поэтому он хочет сократить его вдвое. Но, будучи хорошим ветеринаром, он знает, что не имеет права калечить чужих собак. Поэтому он сначала создает клон собаки (с ключевым словом new) и отрезает этому клону хвост. Когда собака, наконец, вернется к вам, у нее останется прежний 12-дюймовый хвост. Счастливый конец !

В следующий раз, когда вы путешествуете, вы невольно отведите собаку к злому ветеринару. Он также ненавидит длинные хвосты, поэтому сокращает их до жалких 2 дюймов. Но он делает это с твоим дорогим Джимми, а не его клоном. Когда вы возвращаетесь, вы потрясены, увидев, как Джимми жалко виляет двухдюймовым окурком.

Мораль истории: передавая своего питомца, вы передаете ветеринару полную и неограниченную опеку над ним. Он волен устроить им какой-нибудь хаос. Передача по значению, по ссылке, по указателю - все это просто технические споры. Если ветеринар сначала не клонирует его, он в конечном итоге изувечит оригинальную собаку.

public class Doggie {

    public static void main(String...args) {
        System.out.println("At the owner's home:");
        Dog d = new Dog(12);
        d.wag();
        goodVet(d);
        System.out.println("With the owner again:)");
        d.wag();
        badVet(d);
        System.out.println("With the owner again(:");
        d.wag();
    }

    public static void goodVet (Dog dog) {
        System.out.println("At the good vet:");
        dog.wag();
        dog = new Dog(12); // create a clone
        dog.cutTail(6);    // cut the clone's tail
        dog.wag();
    }

    public static void badVet (Dog dog) {
        System.out.println("At the bad vet:");
        dog.wag();
        dog.cutTail(2);   // cut the original dog's tail
        dog.wag();
    }    
}

class Dog {

    int tailLength;

    public Dog(int originalLength) {
        this.tailLength = originalLength;
    }

    public void cutTail (int newLength) {
        this.tailLength = newLength;
    }

    public void wag()  {
        System.out.println("Wagging my " +tailLength +" inch tail");
    }
}

Output:
At the owner's home:
Wagging my 12 inch tail
At the good vet:
Wagging my 12 inch tail
Wagging my 6 inch tail
With the owner again:)
Wagging my 12 inch tail
At the bad vet:
Wagging my 12 inch tail
Wagging my 2 inch tail
With the owner again(:
Wagging my 2 inch tail

В Java есть обходной путь для справки. Позвольте мне объяснить на этом примере:

public class Yo {
public static void foo(int x){
    System.out.println(x); //out 2
    x = x+2;
    System.out.println(x); // out 4
}
public static void foo(int[] x){
    System.out.println(x[0]); //1
    x[0] = x[0]+2;
    System.out.println(x[0]); //3
}
public static void main(String[] args) {
    int t = 2;
    foo(t);
    System.out.println(t); // out 2 (t did not change in foo)

    int[] tab = new int[]{1};
    foo(tab);
    System.out.println(tab[0]); // out 3 (tab[0] did change in foo)
}}

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

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

Возьмем, к примеру, метод badSwap ():

    public void badSwap(int var1, int
 var2{ int temp = var1; var1 = var2; var2 =
 temp; }

Когда badSwap () возвращается, переменные, переданные в качестве аргументов, по-прежнему сохраняют свои исходные значения. Метод также не сработает, если мы изменим тип аргументов с int на Object, поскольку Java также передает ссылки на объекты по значению. Теперь вот где это становится сложным:

public 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("X:
 " + pnt1.x + " Y: " +pnt1.y);

     System.out.println("X: " + pnt2.x + " Y:
 " +pnt2.y); System.out.println(" ");

     tricky(pnt1,pnt2);
 System.out.println("X: " + pnt1.x + " Y:" + pnt1.y);

     System.out.println("X: " + pnt2.x + " Y: " +pnt2.y); }

Если мы выполним этот метод main (), мы увидим следующий результат:

X: 0 Y: 0 X: 0 Y: 0 X: 100 Y: 100 X: 0 Y: 0

Метод успешно изменяет значение pnt1, даже если оно передается по значению; однако поменять местами pnt1 и pnt2 не удается! Это главный источник путаницы. В методе main () pnt1 и pnt2 - это не что иное, как ссылки на объекты. Когда вы передаете pnt1 и pnt2 методу tricky (), Java передает ссылки по значению, как и любой другой параметр. Это означает, что ссылки, переданные в метод, на самом деле являются копиями исходных ссылок. На рисунке 1 ниже показаны две ссылки, указывающие на один и тот же объект после того, как Java передает объект методу.

Java копирует и передает ссылку по значению, а не по объекту. Таким образом, манипуляции с методом изменят объекты, поскольку ссылки указывают на исходные объекты. Но поскольку ссылки являются копиями, обмен не удастся. Как показано на рисунке 2, ссылки на методы меняются местами, но не исходные ссылки. К сожалению, после вызова метода у вас остаются только исходные ссылки без замены. Чтобы замена прошла успешно вне вызова метода, нам нужно поменять местами исходные ссылки, а не копии.

На мой взгляд, «передача по значению» - ужасный способ однозначно описать два похожих, но разных события. Думаю, им следовало сначала спросить меня.

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

Надеюсь, это простое объяснение поможет.

Итог по передаче по значению: вызываемый метод не может изменить переменную вызывающего, хотя для переменных ссылки на объект вызываемый метод может изменить объект, на который ссылается переменная. В чем разница между изменением переменной и изменением объекта? Для объектных ссылок это означает, что вызываемый метод не может переназначить исходную ссылочную переменную вызывающей стороны и сделать ее ссылкой на другой объект или значение null.

Я взял этот код и объяснение из книги по сертификации Java и внес некоторые незначительные изменения.
Я думаю, что это хорошая иллюстрация передачи объекта по значению. В приведенном ниже коде переназначение g не переназначает f! В конце метода bar () были созданы два объекта Foo, на один ссылается локальная переменная f, а на один - локальная (аргументная) переменная g.

Поскольку метод doStuff () имеет копию ссылочной переменной, у него есть способ перейти к исходному объекту Foo, например, вызвать метод setName (). Но у метода doStuff () нет способа добраться до ссылочной переменной f. Таким образом, doStuff () может изменять значения в объекте, на который ссылается f, но doStuff () не может изменять фактическое содержимое (битовый шаблон) f. Другими словами, doStuff () может изменить состояние объекта, на который ссылается f, но не может заставить f ссылаться на другой объект!

package test.abc;

public class TestObject {

    /**
     * @param args
     */
    public static void main(String[] args) {
        bar();
    }

    static void bar() {
        Foo f = new Foo();
        System.out.println("Object reference for f: " + f);
        f.setName("James");
        doStuff(f);
        System.out.println(f.getName());
        //Can change the state of an object variable in f, but can't change the object reference for f.
        //You still have 2 foo objects.
        System.out.println("Object reference for f: " + f);
        }

    static void doStuff(Foo g) {
            g.setName("Boo");
            g = new Foo();
            System.out.println("Object reference for g: " + g);
        }
}


package test.abc;

public class Foo {
    public String name = "";

    public String getName() {
        return name;
    }

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

}

Обратите внимание, что ссылка на объект в выводе консоли ниже не изменилась:

Вывод в консоль:

Ссылка на объект для f: test.abc.Foo@62f72617

Ссылка на объект для g: test.abc.Foo@4fe5e2c3

Ссылка на объект Boo для f: test.abc.Foo@62f72617

Java передает все по значению !!

// создаем объект, передавая имя и возраст:

PersonClass variable1 = new PersonClass("Mary", 32);

PersonClass variable2;

// И переменная 2, и переменная 1 теперь ссылаются на один и тот же объект

variable2 = variable1; 


PersonClass variable3 = new PersonClass("Andre", 45);

// теперь переменная1 указывает на переменную3

variable1 = variable3;

// ЧТО ЭТО ВЫХОДИТ?

System.out.println(variable2);
System.out.println(variable1);

Mary 32
Andre 45

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

веб-страница

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

Класс S

class S{
String name="alam";
public void setName(String n){
this.name=n; 
}}

Образец класса

    public class Sample{
    public static void main(String args[]){
    S s=new S();
    S t=new S();
    System.out.println(s.name);
    System.out.println(t.name);
    t.setName("taleev");
    System.out.println(t.name);
    System.out.println(s.name);
    s.setName("Harry");
    System.out.println(t.name);
    System.out.println(s.name);
    }}

Вывод

алам

алам

Талеев

алам

Талеев

Гарри

Поскольку мы определили класс S с именем переменной экземпляра со значением Taleev, поэтому для всех объектов, которые мы инициализируем из него, будет переменная имени со значением Taleev, но если мы изменим значение имени любых объектов, тогда он меняет имя только этой копии класса (Object) не для каждого класса, поэтому после этого также, когда мы делаем System.out.println (s.name) он печатает талеев, только мы не можем изменить значение имени, которое мы определили изначально, и значение, которое мы изменяем, является значением объекта, а не значением переменной экземпляра, поэтому, как только мы определим переменную экземпляра, мы не могу это изменить

Думаю, именно так это показывает, что java имеет дело с значениями, но не с ссылками.

Распределение памяти для примитивных переменных можно понять с помощью this

Сначала давайте разберемся с распределением памяти в Java: стек и куча являются частью памяти, которую JVM выделяет для различных целей. Память стека заранее выделяется потоку, когда он создается, поэтому поток не может получить доступ к стеку другого потока. Но куча доступна всем потокам в программе.

Для потока Stack хранит все локальные данные, метаданные программы, данные примитивного типа и ссылки на объекты. Причем, Heap отвечает за хранение реального объекта.

Book book = new Book("Effective Java");

В приведенном выше примере ссылочной переменной является «книга», которая хранится в стеке. Экземпляр, созданный оператором new -> new Book («Эффективная Java»), сохраняется в Heap. Переменная ref "book" имеет адрес объекта, размещенного в Heap. Допустим, адрес 1001.

Рассмотрите возможность передачи примитивного типа данных, то есть int, float, double и т. Д.

public class PrimitiveTypeExample { 
    public static void main(string[] args) {
       int num = 10;
       System.out.println("Value before calling method: " + num);
       printNum(num);
       System.out.println("Value after calling method: " + num);
    }
    public static void printNum(int num){
       num = num + 10;
       System.out.println("Value inside printNum method: " + num);
    }
}

Вывод: Значение до вызова метода: 10 Значение внутри метода printNum: 20 Значение после вызова метода: 10

int num = 10; -> это выделяет память для int в стеке запущенного потока, потому что это примитивный тип. Теперь, когда вызывается printNum (..), в том же потоке создается частный стек. Когда "num" передается этому методу, копия "num" создается в кадре стека методов. число = число + 10; -> это добавляет 10 и изменяет переменную int в кадре стека методов. Следовательно, исходное число вне кадра стека методов остается неизменным.

Рассмотрим пример передачи объекта настраиваемого класса в качестве аргумента.

В приведенном выше примере переменная ref "book" находится в стеке потока, выполняющего программу, а объект класса Book создается в пространстве кучи, когда программа выполняет new Book (). Это место в памяти в куче называется «книгой». Когда «книга» передается в качестве аргумента метода, копия «книги» создается в частном стековом фрейме метода в том же стеке потока. Следовательно, скопированная ссылочная переменная указывает на тот же объект класса «Книга» в куче.

Ссылочная переменная в кадре стека методов устанавливает новое значение для того же объекта. Следовательно, это отражается, когда исходная переменная ref "book" получает свое значение. Обратите внимание, что в случае передачи ссылочной переменной, если она снова инициализируется в вызываемом методе, тогда она указывает на новое место в памяти, и любая операция не влияет на предыдущий объект в куче.

Следовательно, когда что-либо передается в качестве аргумента метода, это всегда сущность Stack - либо примитивная, либо ссылочная переменная. Мы никогда не передаем то, что хранится в куче. Следовательно, в Java мы всегда передаем значение в стеке, и оно передается по значению.

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 Давайте разберемся шаг за шагом:

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

первая иллюстрация

new PassByValue().changeValue(t);

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

вторая иллюстрация

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

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

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, как показано ниже:

третья иллюстрация

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

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

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

Но если аргумент ссылки указывает на другой объект, исходная ссылка по-прежнему будет указывать на исходный объект.

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

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

Это важно, так как это экономит много памяти и увеличивает скорость.

public class Test {

    static class Dog {
        String name;

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Dog other = (Dog) obj;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }

        public String getName() {
            return name;
        }

        public void setName(String nb) {
            this.name = nb;
        }

        Dog(String sd) {
            this.name = sd;
        }
    }
    /**
     * 
     * @param args
     */
    public static void main(String[] args) {
        Dog aDog = new Dog("Max");

        // we pass the object to foo
        foo(aDog);
        Dog oldDog = aDog;

        System.out.println(" 1: " + aDog.getName().equals("Max")); // false
        System.out.println(" 2 " + aDog.getName().equals("huahua")); // false
        System.out.println(" 3 " + aDog.getName().equals("moron")); // true
        System.out.println(" 4 " + " " + (aDog == oldDog)); // true

        // part2
        Dog aDog1 = new Dog("Max");

        foo(aDog1, 5);
        Dog oldDog1 = aDog;

        System.out.println(" 5 : " + aDog1.getName().equals("huahua")); // true
        System.out.println(" part2 : " + (aDog1 == oldDog1)); // false

        Dog oldDog2 = foo(aDog1, 5, 6);
        System.out.println(" 6 " + (aDog1 == oldDog2)); // true
        System.out.println(" 7 " + (aDog1 == oldDog)); // false
        System.out.println(" 8 " + (aDog == oldDog2)); // false
    }

    /**
     * 
     * @param d
     */
    public static void foo(Dog d) {
        System.out.println(d.getName().equals("Max")); // true

        d.setName("moron");

        d = new Dog("huahua");
        System.out.println(" -:-  " + d.getName().equals("huahua")); // true
    }

    /**
     * 
     * @param d
     * @param a
     */
    public static void foo(Dog d, int a) {
        d.getName().equals("Max"); // true

        d.setName("huahua");
    }

    /**
     * 
     * @param d
     * @param a
     * @param b
     * @return
     */
    public static Dog foo(Dog d, int a, int b) {
        d.getName().equals("Max"); // true
        d.setName("huahua");
        return d;
    }
}

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

Я бы сказал по-другому:

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

Просто скажу: передача по значению может быть недостаточно понятной для новичков. Например, в Python такая же ситуация, но есть статьи, в которых описывается, что они называют это pass-by-reference, используются только ссылки на причины.

Для простоты и многословности Это pass reference by value:

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
}

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

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

Рассмотрим этот простой пример, String - это объект в java, и когда вы изменяете содержимое строки, ссылочная переменная теперь будет указывать на некоторую новую ссылку, поскольку объекты String неизменяемы в java.

String name="Mehrose";  // name referencing to 100

ChangeContenet(String name){
 name="Michael"; // refernce has changed to 1001

} 
System.out.print(name);  //displays Mehrose

Довольно просто, потому что, как я уже упоминал, вам не разрешено изменять скопированную ссылку в вызывающей функции. Но проблема заключается в массиве, когда вы передаете массив String / Object. Покажи нам.

String names[]={"Mehrose","Michael"};

changeContent(String[] names){
  names[0]="Rose";
  names[1]="Janet"

}

System.out.println(Arrays.toString(names)); //displays [Rose,Janet]

Как мы уже говорили, мы не можем изменить скопированную ссылку в вызове функции, и мы также видели в случае одного объекта String. Причина в том, что переменная names [] ссылается на, скажем, 200, а имена [0] ссылаются на 205 и так далее. Вы видите, что мы не изменили ссылку names [], она по-прежнему указывает на старую ссылку все еще после вызова функции, но теперь ссылка names [0] и names [1] была изменена. Мы по-прежнему придерживаемся нашего определения, что мы не можем изменить ссылку на ссылочную переменную, поэтому мы этого не сделали.

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

Ты не можешь этого сделать

Student student1= new Student("Mehrose");

changeContent(Student Obj){
 obj= new Student("Michael") //invalid
 obj.setName("Michael")  //valid

}

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

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

Для многих это выглядит как передача по ссылке, и поведенчески имеет много общего с передачей по ссылке. Однако есть две причины, по которым это неточно.

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

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

The following code example illustrates this point:
1 public class PassTest {
2
3   // Methods to change the current values
4   public static void changeInt(int value) {
5     value = 55;
6  }
7   public static void changeObjectRef(MyDate ref) {
8     ref = new MyDate(1, 1, 2000);
9  }
10   public static void changeObjectAttr(MyDate ref) {
11     ref.setDay(4);
12   }
13
14 public static void main(String args[]) {
15     MyDate date;
16     int val;
17
18     // Assign the int
19     val = 11;
20     // Try to change it
21     changeInt(val);
22     // What is the current value?
23     System.out.println("Int value is: " + val);
24
25 // Assign the date
26     date = new MyDate(22, 7, 1964);
27     // Try to change it
28     changeObjectRef(date);
29     // What is the current value?
30 System.out.println("MyDate: " + date);
31
32 // Now change the day attribute
33     // through the object reference
34     changeObjectAttr(date);
35     // What is the current value?
36 System.out.println("MyDate: " + date);
37   }
38 }

This code outputs the following:
java PassTest
Int value is: 11
MyDate: 22-7-1964
MyDate: 4-7-1964
The MyDate object is not changed by the changeObjectRef method;
however, the changeObjectAttr method changes the day attribute of the
MyDate object.

Вот более точное определение:

• Передача / вызов по значению: формальный параметр подобен локальной переменной в области действия функции, он оценивается как фактический параметр в момент вызова функции.
• Передача / вызов по ссылке: формальный параметр - это просто псевдоним для реального значения, любое его изменение в области действия функции может иметь побочные эффекты за пределами любой другой части кода.

Итак, в C / C ++ вы можете создать функцию, которая меняет местами два значения, переданные с использованием ссылок:

void swap(int& a, int& b) 
{
    int tmp = a; 
    a = b; 
    b = tmp; 
}

Вы можете видеть, что у него есть уникальная ссылка на a и b, поэтому у нас нет копии, tmp просто хранит уникальные ссылки.

Та же функция в java не имеет побочных эффектов, передача параметров такая же, как в приведенном выше коде, без ссылок.

Хотя java работает с указателями / ссылками, параметры не являются уникальными указателями, в каждой атрибуции они копируются, а не просто назначаются как C / C ++

Пожалуйста прочтите это.

Многие языки программирования позволяют передавать параметры по ссылке или по значению. В Java мы можем передавать параметры только по значению. Это накладывает некоторые ограничения, а также вызывает вопросы. Например, если в методе изменяется значение параметра, что происходит со значением после выполнения метода? Вы также можете задаться вопросом, как Java управляет значениями объектов в куче памяти. Этот Java Challenger поможет вам решить эти и другие распространенные вопросы о ссылках на объекты в Java.

Для получения дополнительной информации:

https://www.javaworld.com/article/3512039/does-java-pass-by-reference-or-pass-by-value.html

Есть только две версии:

• Вы можете передать значение, например (4,5)
• Вы можете передать адрес, например 0xF43A

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

В C ++ вы можете делать следующее:

Point p = Point(4,5);

Это резервирует 8 байтов в стеке и сохраняет в нем (4,5).

Point *x = &p;

Это резервирует 4 байта в стеке и сохраняет в нем 0xF43A.

Point &y = p;

Это резервирует 4 байта в стеке и сохраняет в нем 0xF43A.

1. Я думаю, все согласятся, что вызов f (p) - это передача по значению, если определение f равно f (точка p). В этом случае зарезервированы дополнительные 8 байтов и (4,5) скопированы в них. Когда f меняет p, оригинал гарантированно не изменится, когда f вернется.

2. Я думаю, что все согласятся, что вызов f (p) является передачей по ссылке, если определение f равно f (Point & p). В этом случае зарезервированы дополнительные 4 байта и в них копируется 0xF43A. Когда f меняет p, гарантируется, что оригинал будет изменен, когда f вернется.

3. Вызов f (& p) также передается по ссылке, если определение f - f (Point * p). В этом случае зарезервированы дополнительные 4 байта и в них копируется 0xF43A. Когда f меняет * p, гарантируется, что оригинал будет изменен, когда f вернется.

4. Вызов f (x) также передается по ссылке, если определение f - f (Point * p). В этом случае зарезервированы дополнительные 4 байта и в них копируется 0xF43A. Когда f меняет * p, гарантируется, что оригинал будет изменен, когда f вернется.

5. Вызов f (y) также передается по ссылке, если определение f - f (Point & p). В этом случае зарезервированы дополнительные 4 байта и в них копируется 0xF43A. Когда f меняет p, гарантируется, что оригинал будет изменен, когда f вернется.

Конечно, то, что происходит после передачи, отличается, но это только языковая конструкция. В случае указателя вы должны использовать - ›для доступа к элементам, а в случае ссылок, которые вы должны использовать .. Если вы хотите поменять местами значения оригинала, вы можете сделать tmp = a; а = б; b = tmp; в случае ссылок и tmp = * a; * b = tmp; * a = tmp для указателей. А в Java вам нужно: tmp.set (a); a.set (b); b.set (tmp). Сосредоточиться на операторе присваивания глупо. Вы можете сделать то же самое на Java, если напишете немного кода.

Таким образом, Java передает примитивы по значениям и объекты по ссылкам. И Java копирует значения для этого, как и C ++.

Для полноты:

Point p = new Point(4,5);

Это резервирует 4 байта в стеке и сохраняет в нем 0xF43A, а также резервирует 8 байтов в куче и сохраняет в нем (4,5).

Если вы хотите поменять местами места в памяти вот так

void swap(int& a, int& b) {
    int *tmp = &a;
    &a = &b;
    &b = tmp;
}

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

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

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

(Таким образом, вы можете изменить исходный объект, но не можете получить доступ к исходной ссылке)

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

Этот код показывает, как можно сделать что-то вроде этого:

public class Test
{
    private static void needValue(SomeObject so) throws CloneNotSupportedException
    {
        SomeObject internalObject = so.clone();
        so=null;
        
        // now we can edit internalObject safely.
        internalObject.set(999);
    }
    public static void main(String[] args)
    {
        SomeObject o = new SomeObject(5);
        System.out.println(o);
        try
        {
            needValue(o);
        }
        catch(CloneNotSupportedException e)
        {
            System.out.println("Apparently we cannot clone this");
        }
        System.out.println(o);
    }
}

public class SomeObject implements Cloneable
{
    private int val;
    public SomeObject(int val)
    {
        this.val = val;
    }
    public void set(int val)
    {
        this.val = val;
    }
    public SomeObject clone()
    {
        return new SomeObject(val);
    }
    public String toString()
    {
        return Integer.toString(val);
    }
}

Здесь у нас есть функция needValue, и она сразу же создает клон объекта, который необходимо реализовать в классе самого объекта, и этот класс нужно пометить как Cloneable. После этого не обязательно устанавливать so в null, но я сделал это здесь, чтобы показать, что мы не собираемся использовать эту ссылку после этого.

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