Java是“旁路”还是“按值”?

I always thought Java was pass-by-reference, however I've seen a couple of blog posts (For example, this blog) that claim it isn't. I don't think I understand the distinction they're making.

我一直认为Java是一个附带引用，但是我看到过一些博客文章(例如，这个博客)声称它不是。我不理解他们的区别。

What is the explanation?

解释是什么?

79 个解决方案

#1

4482

Java is always pass-by-value. Unfortunately, they decided to call the location of an object a "reference". When we pass the value of an object, we are passing the reference to it. This is confusing to beginners.

Java总是按值传递。不幸的是，他们决定将对象的位置称为“引用”。当我们传递一个对象的值时，我们将引用它。这让初学者很困惑。

It goes like this:

它是这样的:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    // 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, java passes by value
    aDog.getName().equals("Fifi"); // false 
}

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
}

In the example above aDog.getName() will still return "Max". The value aDog within main is not changed in the function foo with the Dog "Fifi" as the object reference is passed by value. If it were passed by reference, then the aDog.getName() in main would return "Fifi" after the call to foo.

在上面的例子中，aDog.getName()仍然返回“Max”。main中的值aDog在函数foo中没有改变，而Dog“Fifi”作为对象引用是通过值传递的。如果它是通过引用传递的，那么main中的aDog.getName()将在调用foo之后返回“Fifi”。

Likewise:

同样的:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    foo(aDog);
    // when foo(...) returns, the name of the dog has been changed to "Fifi"
    aDog.getName().equals("Fifi"); // true
}

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

In the above example, Fifi is the dog's name after call to foo(aDog) because the object's name was set inside of foo(...). Any operations that foo performs on d are such that, for all practical purposes, they are performed on aDog itself (except when d is changed to point to a different Dog instance like d = new Dog("Boxer")).

在上面的例子中，Fifi是在调用foo(aDog)之后的狗的名字，因为对象的名称是在foo(…)中设置的。foo在d上执行的任何操作都是这样的，出于所有实际目的，它们都是在aDog本身上执行的(除了d被更改为指向一个不同的Dog实例，比如d = new Dog(“Boxer”))。

#2

2534

I just noticed you referenced my article.

我刚注意到你引用了我的文章。

The Java Spec says that everything in Java is pass-by-value. There is no such thing as "pass-by-reference" in Java.

Java规范说，Java中的一切都是按值传递的。在Java中没有所谓的“附带引用”。

The key to understanding this is that something like

理解这一点的关键是。

Dog myDog;

is not a Dog; it's actually a pointer to a Dog.

不是一条狗;它实际上是一个指向狗的指针。

What that means, is when you have

这意味着什么，当你拥有!

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

you're essentially passing the address of the created Dog object to the foo method.

您实际上是将创建的Dog对象的地址传递给foo方法。

(I say essentially because Java pointers aren't direct addresses, but it's easiest to think of them that way)

(我之所以说，本质上是因为Java指针不是直接地址，但最容易想到的是它们)

Suppose the Dog object resides at memory address 42. This means we pass 42 to the method.

假设Dog对象驻留在内存地址42中。这意味着我们把42传递给这个方法。

if the Method were defined as

如果方法被定义为。

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

let's look at what's happening.

让我们看看发生了什么。

the parameter someDog is set to the value 42
someDog的参数设置为42。
at line "AAA"
- someDog is followed to the Dog it points to (the Dog object at address 42)
- 有些狗被跟踪到它指向的狗(狗的对象在地址42)
- that Dog (the one at address 42) is asked to change his name to Max
- 那只狗(地址是42)被要求把他的名字改成马克斯。
在“AAA”级的狗狗被跟踪到它指向的狗(地址是42)那条狗(地址为42)被要求将他的名字改为马克斯。
at line "BBB"
- a new Dog is created. Let's say he's at address 74
- 一条新狗诞生了。假设他在地址74。
- we assign the parameter someDog to 74
- 我们将参数someDog指定为74。
在“BBB”线上，一条新狗诞生了。假设他在地址74，我们将参数someDog分配给74。
at line "CCC"
- someDog is followed to the Dog it points to (the Dog object at address 74)
- 有些狗被跟踪到它指向的狗(狗的对象在地址74)
- that Dog (the one at address 74) is asked to change his name to Rowlf
- 那只狗(地址为74)被要求把他的名字改为Rowlf。
在“CCC”这条狗狗的后面，它指向狗狗(地址为74)那条狗(地址为74)被要求将他的名字改为Rowlf。
then, we return
然后,我们返回

Now let's think about what happens outside the method:

现在让我们考虑一下在方法之外会发生什么

Did myDog change?

myDog改变吗?

There's the key.

的关键。

Keeping in mind that myDog is a pointer, and not an actual Dog, the answer is NO. myDog still has the value 42; it's still pointing to the original Dog (but note that because of line "AAA", its name is now "Max" - still the same Dog; myDog's value has not changed.)

记住，我的狗是一个指针，而不是一只真正的狗，答案是否定的。myDog仍然有值42;它仍然指向原来的狗(但请注意，因为“AAA”，它的名字现在是“Max”——仍然是同一只狗;myDog的价值没有改变。

It's perfectly valid to follow an address and change what's at the end of it; that does not change the variable, however.

遵循一个地址并改变它的结尾是完全有效的;然而，这并不会改变变量。

Java works exactly like C. You can assign a pointer, pass the pointer to a method, follow the pointer in the method and change the data that was pointed to. However, you cannot change where that pointer points.

Java就像c一样工作，你可以分配一个指针，将指针传递给一个方法，跟踪方法中的指针并改变指向的数据。但是，您不能更改指针指向的位置。

In C++, Ada, Pascal and other languages that support pass-by-reference, you can actually change the variable that was passed.

在c++、Ada、Pascal和其他支持传递引用的语言中，您实际上可以更改传递的变量。

If Java had pass-by-reference semantics, the foo method we defined above would have changed where myDog was pointing when it assigned someDog on line BBB.

如果Java具有传递引用的语义，那么我们在上面定义的foo方法将会在myDog的位置上发生变化。

Think of reference parameters as being aliases for the variable passed in. When that alias is assigned, so is the variable that was passed in.

考虑引用参数作为传入变量的别名。当这个别名被分配时，传入的变量也是。

#3

1324

Java always passes arguments by value NOT by reference.

Java总是通过值而不是引用传递参数。

Let me explain this through an example:

让我通过一个例子来解释这一点:

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");
     }
}

I will explain this in steps:

我将在以下步骤中解释:

Declaring a reference named f of type Foo and assign it to a new object of type Foo with an attribute "f".

声明一个名为Foo类型的引用，并将其分配给Foo类型的新对象，并带有一个属性“f”。
```
Foo f = new Foo("f");
```
From the method side, a reference of type Foo with a name a is declared and it's initially assigned to null.

从方法方面来说，声明了一个名称为a的Foo类型的引用，它最初被赋值为null。
```
public static void changeReference(Foo a)
```
As you call the method changeReference, the reference a will be assigned to the object which is passed as an argument.

当您调用方法changeReference时，引用a将被分配给作为参数传递的对象。
```
changeReference(f);
```
Declaring a reference named b of type Foo and assign it to a new object of type Foo with an attribute "b".

声明一个名为Foo类型的引用，并将其分配给一个带有“b”属性的Foo类型的新对象。
```
Foo b = new Foo("b");
```
a = b is re-assigning the reference a NOT f to the object whose its attribute is "b".

a = b重新分配对其属性为“b”的对象的引用a而非f。
As you call modifyReference(Foo c) method, a reference c is created and assigned to the object with attribute "f".

当您调用modifyReference(Foo c)方法时，将创建一个引用c，并将其分配给具有属性“f”的对象。
c.setAttribute("c"); will change the attribute of the object that reference c points to it, and it's same object that reference f points to it.

c.setAttribute(“c”);将会改变引用c指向它的对象的属性，它与引用f指向它的对象相同。

I hope you understand now how passing objects as arguments works in Java :)

我希望您现在能够理解如何将对象作为参数在Java中工作:)

#4

631

This will give you some insights of how Java really works to the point that in your next discussion about Java passing by reference or passing by value you'll just smile :-)

这将给您提供一些关于Java如何真正起作用的见解，在您下次讨论Java通过引用或传递值时，您只需微笑:-)

Step one please erase from your mind that word that starts with 'p' "_ _ _ _ _ _ _", especially if you come from other programming languages. Java and 'p' cannot be written in the same book, forum, or even txt.

第一步，请从你的脑海中抹去“p”开头的单词“_ _ _ _ _ _”，尤其是你来自其他编程语言的时候。Java和“p”不能写在同一本书、论坛甚至txt中。

Step two remember that when you pass an Object into a method you're passing the Object reference and not the Object itself.

第二步记住，当你将一个对象传递给一个方法时，你传递的是对象引用而不是对象本身。

Student: Master, does this mean that Java is pass-by-reference?
学生:大师，这是否意味着Java是间接引用?
Master: Grasshopper, No.
主:蚱蜢,没有。

Now think of what an Object's reference/variable does/is:

现在想想对象的引用/变量是什么

A variable holds the bits that tell the JVM how to get to the referenced Object in memory (Heap).
一个变量包含告诉JVM如何到达内存中的引用对象的位(堆)。
When passing arguments to a method you ARE NOT passing the reference variable, but a copy of the bits in the reference variable. Something like this: 3bad086a. 3bad086a represents a way to get to the passed object.
当将参数传递给方法时，您不会传递引用变量，而是引用变量中的位的副本。这样的:3 bad086a。3bad086a代表一种到达被传递对象的方法。
So you're just passing 3bad086a that it's the value of the reference.
你只是通过了3bad086a这是参考值。
You're passing the value of the reference and not the reference itself (and not the object).
您正在传递引用的值，而不是引用本身(而不是对象)。
This value is actually COPIED and given to the method.
这个值实际上是被复制的，并被赋予了这个方法。

In the following (please don't try to compile/execute this...):

在下面(请不要试图编译/执行这个…):

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. }

What happens?