java 一直是值传递

这是一篇译文，原文：

https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value

如果你看不完，或者看不懂，请直接看后记的结论。

问题描述：

我过去一直以为 java 是pass-by-reference但是我见了一个帖子说不是的。我觉得自己不明白其中的区别，解释是什么？

回答如下：

请记住 java 一直是值传递 。

但是很不幸，他们决定把一个对象的地址称为reference.实际上我们可以这样说：

当我们把一个对象的值传递过去的时候，我们其实就是在传递它的引用（reference）

大概可能对初学者， 这一点让他们会感到困惑

来吧，我们来一起看看：

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 }

在这个例子里，aDog.getName()将会仍旧返回"Max".

在main里的aDog没有被foo（）函数改变。要是是call-by-reference的话，我们应该能够预见，在调用foo（）后，aDog.getName()应该返回Fifi。而实际上，并没有。

同样地：

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

在上面的例子中，Fifi就是在调用foo()后，狗的名字了。因为对象的名字被设置成了Fifi。

再举出最后一个例子：

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. //在调用init方法后，obj仍旧指向空 //这是因为，obj是值传递，而不是引用传递。 } private void init(MyClass objVar) { objVar = new MyClass(); }

最后一句话：

In Java only references are passed and are passed by value

java中只有引用被传递了，而且是以值传递的方式

后记（20181030）

我回头看自己的文章都不知道写的啥意思，所以我又做了一次检验。我把结论说明白

结论：

你传进去函数的值(比如a)只是一个寻址的钩子，钩子的指向（也就是这个值）可以改变（比如改变成b,c,d…)，当你在子函数中玩完，退出了，你钩子指向的变更，都是无效的。

外层函数继续它的一切时，会发现钩子的a值 曾经 被传递到子函数中，但是无论子函数对这个值（a）怎么变更（比如：a=b)，回到主函数我这里 ，a还是a

总结（20181109）

当子函数内，令这个引用去指向新的内存了（by new 关键字），那么我们现在对同名的那个原来的引用，其实已经是指向新的内存地址（对应着一个新的对象），我们现在对引用的任何操作，都无法影响原来的那个引用了。 当子函数内，直接调用这个原引用的一些内置行为，改变了其属性，那么现在是确实地改变了其属性。

Java 是传递的引用，一个引用： 你可以理解为一个内存地址，一个容器，装着对象的实例，每个容器都有个名字，也就是我们声明变量时，给变量的那个名字。

那么，1》如果我们不赋新的（内存，引用）值，那么一切都好好的， 我们改了对象的什么，就真的改了，2》如果有新的值赋值给原引用，那么其实是子函数局部的这个容器装了一个新的内存地址，aka 新的引用，而对新的容器的任何变更，将不会影响到原容器。

范例：

public class RefTest { public static void main(String[] args) { TreeNode bNode = new TreeNode(null, null, 2); TreeNode cNode = new TreeNode(null, null, 3); TreeNode aNode = new TreeNode(bNode, cNode, 1); addressing(aNode);// System.out.println("a is new 3???" + aNode.val); } public static void addressing(TreeNode root) { root = root.right; } } class TreeNode { TreeNode left; TreeNode right; int val; TreeNode(TreeNode left, TreeNode right, int val) { this.left = left; this.right = right; this.val = val; } } /*output : a is new 3???1 the reference you are getting is a value reference that if overwritten will be restored when exiting the function. 你传进去函数的值(比如a)只是一个寻址的钩子，钩子的指向（也就是这个值）可以改变（比如改变成b,c,d...)，当你在子函数中玩完，退出了，你钩子指向的变更，都是无效的。 外层函数继续它的一切时，会发现钩子的a值 *曾经* 被传递到子函数中，但是无论子函数对这个值（a）怎么变更（a=b)，回到主函数我这里 ， a还是a */