许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。
与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。
现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。【这儿补充一句，如果只是操作数据的引用，则原数组是不会改变的！！！】看下面的例子：
public static void main(String[] args) {
aboutParamTransporting1();
}
private static void aboutParamTransporting1() {
int a = 1;
int b = 2;
swap(a, b);
System.out.printf("a=%d, b=%d \n", a, b);
int[] x = new int[] { 10, 20 };
int[] y = new int[] { 30, 50 };
System.out.println("只是改变引用，原数组不变");
swap(x, y);
System.out.printf("x={%d, %d} \n", x[0], x[1]);
System.out.printf("y={%d, %d} \n", y[0], y[1]);
System.out.println("修改原数组对象，则原数组改变");
swapAndChange(x, y);
System.out.printf("x={%d, %d} \n", x[0], x[1]);
System.out.printf("y={%d, %d} \n", y[0], y[1]);
}
private static void swap(int[] is, int[] js) {
// 只是修改引用，原数组是不改变的。
int[] x = is;
is = js;
js = x;
}
private static void swapAndChange(int[] is, int[] js) {
// 数组交换，此时操作的只是引用哦~
int[] x = is;
is = js;
js = x;
// 修改原数组
is[0] = 1;
js[0] = 2;
}
对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。
下面看个小程序：
public class TestPrimitiveType {
String str = new String("good");
char[] ch = {'a', 'b', 'c'};
int i = 10;
public void change(String str, char[] ch, int i) {
str = "test ok";
ch[0] = 'g';
i++;
}
public static void main(String[] args) {
TestPrimitiveType testPrimitiveType = new TestPrimitiveType();
testPrimitiveType.change(testPrimitiveType.str, testPrimitiveType.ch, testPrimitiveType.i);
System.out.println(testPrimitiveType.i);
System.out.println(testPrimitiveType.str);
System.out.println(testPrimitiveType.ch);
}
}
str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用
在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；
而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；
i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。
所以结果是：
10
good
gbc
现在咱们把代码变化一下：
public class TestPrimitiveType {
String str = new String("good");
char[] ch = {'a', 'b', 'c'};
int i = 10;
public void change(String str, char ch, int i) {
str = "test ok";
ch = 'g';
this.i = i + 1;
}
public static void main(String[] args) {
TestPrimitiveType testPrimitiveType = new TestPrimitiveType();
testPrimitiveType.change(testPrimitiveType.str, testPrimitiveType.ch[0], testPrimitiveType.i);
System.out.println(testPrimitiveType.i);
System.out.println(testPrimitiveType.str);
System.out.println(testPrimitiveType.ch);
}
}
仔细观察下实参以及入参有何变化？
change()方法里的入参char[] ch变成--------------char ch;
这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='9';是不影响源数组元素的。
this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；
此时i+1后赋值给属性的i，自然会改变属性i的值，同时15行，tt.i又是调用属性的i.
这次的结果是：
11
good
abc
现在是不是有点明白了？
那好再看下面一个小程序
public class TestPrimitiveType {
public void change(StringBuffer x, StringBuffer y) {
x.append(y);
y = x;
}
public static void main(String[] args) {
StringBuffer bufferA = new StringBuffer("a");
StringBuffer bufferB = new StringBuffer("b");
new TestPrimitiveType().change(bufferA, bufferB);
System.out.println(bufferA + ", " + bufferB);
}
}
这次传递的是两个对象的引用的值，
在方法change()里 的x.append(y), 其中引用x调用api方法append()修改了new StringBuffer("a");的内容。
y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量，所以输出结果是：
ab,b
下面是个稍难的小程序，先自己用笔画画过程，写出自己的结果，而后再上机操作下，如果自己的结果和在电脑上的结果一样，那么再碰到这类题就不难了，如果不一样，回头仔细体会下我前面的讲解，找找原因。
public class TestPrimitiveType {
private String nn = new String("1");
private String[] mm = {"2", "5"};
void test(String nn, String[] mm) {
nn = new String("3");
this.nn = "9";
mm[0] = "4";
System.out.println("in test(), mm[0]: " + mm[0]);
mm = new String[]{"8", "7"};
System.out.println("in test(), nn:" + nn);
System.out.println("in test(), this.nn: " + this.nn);
System.out.println("in test(), mm[0]: " + mm[0]);
}
public static void main(String[] args) {
TestPrimitiveType testPrimitiveTye = new TestPrimitiveType();
testPrimitiveTye.test(testPrimitiveTye.nn, testPrimitiveTye.mm);
System.out.println(testPrimitiveTye.nn + " " + testPrimitiveTye.mm[0]);
}
}
运行结果为：
in test(), mm[0]: 4
in test(), nn:3
in test(), this.nn: 9
in test(), mm[0]: 8
9 4
具体原因看下面的注释：
public class TestPrimitiveType {
private String nn = new String("1");
private String[] mm = {"2", "5"};
void test(String nn, String[] mm) {
nn = new String("3"); // 传入参数变为 3
this.nn = "9";
mm[0] = "4";
System.out.println("in test(), mm[0]: " + mm[0]); // 4, 对外面有影响
mm = new String[]{"8", "7"}; // new, 跟原来的mm没关系了。指向了新的引用地址
System.out.println("in test(), nn:" + nn); // 传入的参数修改后的值 3
System.out.println("in test(), this.nn: " + this.nn); // 改变了， 9
System.out.println("in test(), mm[0]: " + mm[0]); // 新的mm, 此时mm[0]为 8
}
public static void main(String[] args) {
TestPrimitiveType testPrimitiveTye = new TestPrimitiveType();
testPrimitiveTye.test(testPrimitiveTye.nn, testPrimitiveTye.mm);
System.out.println(testPrimitiveTye.nn + " " + testPrimitiveTye.mm[0]); // 9 4
}
}
参考文献：
