Java的传值

这个问题一直以来都有误区。本质原因是那些写书的人，喜欢用“传引用”的这个概念，从而混淆Java传值的本质。

 

Java中参数的传递只有传值方式。
首先必须搞清楚，普通变量和引用变量。

 

普通变量：其内存单元即存的是值本身。如int值，其内存值只是自己的值。

引用变量：其内存单元存储的是一块内存的地址。其概念与指针是一样的。

 

在Java调用函数传递值的时候，函数外变量总是把自己的值赋给函数的参数变量。注意参数变量和函数外变量其内存单元的地址是不一样的，两个是不同的东西。

 

函数外变量传值给函数参数，函数参数的值发生改变，不影响到函数外部变量的值。

public class StringArg {
	//Java中总是使用传值调用。
	
	public static String cao ="cao!";
	public static MyFinal final1 = new MyFinal();
	public static MyUnFinal final2 = new MyUnFinal();
	public static int int1 = 1;
	
	public static void m1(String arg){
		System.out.println("m1方法执行，输入参数为："+arg);
		arg = "123";
		System.out.println("m1方法结束，输出参数为："+arg);
	}
	
	public static void m2(MyFinal arg){
		System.out.println("m2方法执行，输入参数为："+arg.toString());
		arg = new MyFinal();
		System.out.println("m2方法结束，输出参数为："+arg.toString());
	}
	
	public static void m3(MyUnFinal arg){
		System.out.println("m3方法执行，输入参数为："+arg.toString());
		arg = new MyUnFinal();
		System.out.println("m3方法结束，输出参数为："+arg.toString());
	}
	
	public static void m4(int arg){
		System.out.println("m4方法执行，输入参数为："+arg);
		arg = 2;
		System.out.println("m4方法结束，输出参数为："+arg);
	}
	
	public static void main(String[] args) {
		m1(cao);
		System.out.println("main方法中调用m1方法之后的参数值："+cao);
		System.out.println();
		
		m2(final1);
		System.out.println("main方法中调用m2方法之后的参数值："+final1);
		System.out.println();
		
		m3(final2);
		System.out.println("main方法中调用m3方法之后的参数值："+final2);
		System.out.println();
		
		m4(int1);
		System.out.println("main方法中调用m4方法之后的参数值："+int1);
		System.out.println();
	}
}


final class MyFinal{}

class MyUnFinal{}

 以上代码输出的结果为：

m1方法执行，输入参数为：cao!
m1方法结束，输出参数为：123
main方法中调用m1方法之后的参数值：cao!

m2方法执行，输入参数为：MyFinal@61de33
m2方法结束，输出参数为：MyFinal@14318bb
main方法中调用m2方法之后的参数值：MyFinal@61de33

m3方法执行，输入参数为：MyUnFinal@ca0b6
m3方法结束，输出参数为：MyUnFinal@10b30a7
main方法中调用m3方法之后的参数值：MyUnFinal@ca0b6

m4方法执行，输入参数为：1
m4方法结束，输出参数为：2
main方法中调用m4方法之后的参数值：1

 

可以看出函数方法无法影响到函数外部变量的值。

说明：

1、对于m1(String arg)字符串参数传递的问题，该问题非常经典。经常出现在面试中。

2、对于m2()和m3()方法，参数在函数内部重新分配了新的内存地址，即函数的参数有了新的值。但是外部变量的值没有变化。

 

之前一直会把以上问题与下面这个例子搞混掉

public class StringArg {
	
	public static MyObject myObject = new MyObject("cao!");
	
	public static void m5(MyObject arg){
		System.out.println("m5方法执行，输入参数为："+arg.name);
		arg.name = "123";
		System.out.println("m5方法结束，输出参数为："+arg.name);
	}
	
	
	public static void main(String[] args) {
		m5(myObject);
		System.out.println("main方法中调用m5方法之后的参数值："+myObject.name);
		System.out.println();
	}
}


class MyObject{
	public String name = "";
	public MyObject(String name){
		this.name = name;
	}
}

 输出当然是：

m5方法执行，输入参数为：cao!
m5方法结束，输出参数为：123
main方法中调用m5方法之后的参数值：123

 该例中，参数变量并没有重新与新对象绑定，即没有获得新值。在原值所指向的内存区域将对象进行修改。