Java的值传递和引用传递
网络上能搜索到的资料里，关于Java到底是值传递还是引用传递的讨论是比较多的，也没有一个特别被大家认可的结论。
因为最近一两年转到了Golang的开发，接触到了比较多的指针的玩法，突然对Java的引用传递和值传递又有了一定的兴趣。
但是我无意于讨论Java到底是值传递还是引用传递，我只是记录一下，避免以后开发的时候踩坑。
为了验证，我写了这么一段代码：
private void transInt(int x) {
x += 100;
}
// 这段代码的调用逻辑如下：
int x = 10;
m.transInt(x);
System.out.println("-----------------after int trans----------------");
System.out.println(x);
这段代码不出意外的会打印10，从这一点上看，Java是值传递的，因为传入transInt的是x的一个副本。
不过事情并不会这么简单的结束，上面的例子太特殊了，我使用的是Java提供的基本类型。
换成String类型是否还能如此，这是一个值的验证的问题，所以应该实现这样一段代码：
private void transString(String x) {
x += "bar";
}
// 这段代码的调用逻辑如下：
String str = "foo";
m.transString(str);
这段代码的执行结果是"foo"，也就是说非基本类型也是值传递。
事情到了这一步似乎是可以说Java是值传递了，但是事情并不会这么简单的结束，我实现了一个类：
class Solution implements Cloneable {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return (Solution) super.clone();
}
}
然后实现了一个方法：
private void transfer(Solution solution) {
solution.setAge(12);
solution.setName("lee");
}
// 调用方法如下：
Solution solution = new Solution();
solution.setName("foo");
solution.setAge(20);
System.out.println("--------------before transfer------------------------");
System.out.println(solution.getAge());
System.out.println(solution.getName());
m.transfer(solution);
System.out.println("--------------after transfer-------------------");
System.out.println(solution.getAge());
System.out.println(solution.getName());
打印结果如下：
--------------before transfer------------------------
20
foo
--------------after transfer-------------------
12
lee
这种结果很明显就是引用传递了。事到如今又可以说Java是引用传递了。
所以不能简单的说Java是值传递还是引用传递，这里的水还是比较深的，如果不是很了解，很可能在代码实现的时候出现一些奇怪的问题。
这一点上我觉得Java偷感比较重，同样的如果是Golang，则比较直接。
比如这段代码：
package main
import "fmt"
type Student struct {
Name string
Age int
}
func transStu(stu Student) {
stu.Age = 12
stu.Name = "bar"
}
func transStuPoint(stu *Student) {
stu.Age = 100
stu.Name = "lee"
}
func main() {
stu := &Student{
Name: "foo",
Age: 21,
}
fmt.Printf("%s:%d\n", stu.Name, stu.Age)
transStu(*stu)
fmt.Printf("%s:%d\n", stu.Name, stu.Age)
transStuPoint(stu)
fmt.Printf("%s:%d\n", stu.Name, stu.Age)
}
如果传入的是值，那么就是值传递，如果传入的是指针，那么就是引用传递，控制权交给程序员，所以这段代码的打印结果就是：
foo:21
foo:21
lee:100
之前学习C语言的时候，就是因为受不了这么灵活的指针而转投Java，但是现在看来，C语言把大部分的控制权交给程序员不失为一种明智的选择。
基本没见过网上有讨论C或者Go是值传递还是引用传递的。
使用Golang有一点好处就是一下子点开了我的C语言。C语言的好处就是把选择权交给程序员，基本上程序员就是程序的王，如果用C语言的话是不存在这种值传递还是引用传递的争议的，比如下面的代码：
#include<stdio.h>
int main() {
printf("before trans1\n");
int a1 = 10;
printf("input value is %d, input address is %p\n", a1, &a1);
trans1(a1);
printf("after trans1\n");
printf("%d\n", a1);
int a2 = 11;
printf("before trans2\n");
printf("input value is %d, input address is %p\n", a2, &a2);
printf("%d\n", a2);
trans2(&a2);
printf("after trans2\n");
printf("%d\n", a2);
return 0;
}
// 传入的是一个值
void trans1(int x)
{
// 这里的打印值应该和main函数里的不一致，因为传入的是一个全新的数
printf("input x value is %d, input address is %p\n", x, &x);
x += 100;
}
// 传入的是int型指针
void trans2(int * x)
{
// 这里应该和外层的打印值是一样的
printf("input x value is %d, input address is %p\n", *x, x);
// 取值之后，加100,
*x += 100;
}
打印结果：
before trans1
input value is 10, input address is 0x7ffffcc3c
(下一行的地址和上面不同，传给trans1的实际上是一个全新的值)
input x value is 10, input address is 0x7ffffcc10
after trans1
10
before trans2
input value is 11, input address is 0x7ffffcc38
11
input x value is 11, input address is 0x7ffffcc38
（传给trans2的实际是一段地址，和上面的打印结果相同）
after trans2
111
