java中的值传递和引用传递2<原文：http://blog.csdn.net/niuniu20008/article/details/2953785>

与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。 

现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

例1：

1.public class Test{
2.    
3.    String str = new String("good");
4.    char[] ch = {'a','b','c'};
5.    int i = 10;
6.    public void change(String str,char[] ch,int i){
7.    
8.        str = "test ok";
9.        ch[0] = 'g';
10.        i++;    
11.    }
12.    
13.    public static void main(String[] args){
14.    
15.        Test tt = new Test();
16.        tt.change(tt.str,tt.ch,tt.i);
17.        System.out.println(tt.i);//10
18.        System.out.print(tt.str+" and ");//good and
19.        System.out.println(tt.ch); //gbc    
20.    }
21.}

str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用

在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；

而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；

i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。

例2：

1.public class Test{
2.    
3.    String str = new String("good");
4.    char[] ch = {'a','b','c'};
5.    int i = 10;
6.    public void change(String str,char ch,int i){
7.    
8.        str = "test ok";
9.        ch = 'g';
10.        this.i = i+1;    
11.    }
12.    
13.    public static void main(String[] args){
14.    
15.        Test tt = new Test();
16.        tt.change(tt.str,tt.ch[0],tt.i);
17.        System.out.println(tt.i);//11
18.        System.out.print(tt.str+" and ");//good and
19.        System.out.println(tt.ch);//abc     
20.    }
21.}

change()方法里的入参char[] ch变成----char ch;这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='g';是不影响源数组元素的。

this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；此时i+1后赋值给属性的i，自然会改变属性i的值，同时17行，tt.i又是调用属性的i

例3：

1.public class Test{
2.    
3.    public void change(StringBuffer x,StringBuffer y){
4.        
5.        x.append(y);
6.        y=x;    
7.    }
8.    public static void main(String[] args){
9.    
10.        StringBuffer buffA = new StringBuffer("a");
11.        StringBuffer buffB = new StringBuffer("b");
12.        new Test().change(buffA,buffB);
13.        System.out.println(buffA+","+buffB);//ab,b 
14.    }
15.}

这次传递的是两个对象的引用的值，在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。 y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量。

例4：

1.public class Test{
2.    
3.    private String nn = new String("1");
4.    private String[] mm = {"2","5"};
5.    
6.    void test(String nn,String[] mm){
7.        
8.        nn = new String("3");
9.        this.nn = "9";
10.        
11.        mm[0] = "4";
12.        System.out.println("in test(),mm[0]: "+mm[0]);//4
13.        mm = new String[]{"8","7"};
14.        System.out.println("in test(),nn: "+nn);//3
15.        System.out.println("this.nn: "+this.nn);//9
16.        System.out.println("mm[0]: "+mm[0]);//8
17.    }
18.    
19.    public static void main(String[] args){
20.        
21.        Test s = new Test();
22.        s.test(s.nn,s.mm);
23.        System.out.println(s.nn+"  "+s.mm[0]);//9 4
24.    }
25.}