Java值传递、引用传递、数组的传递

最近复习Java。首先，看一个CSDN上的问题，原问题是”Java中，当函数参数为类对象时，到底怎么传递？“

下面是粘贴代码：

class User{
   private String userName;
 
   public String getUserName() {
      return userName;
   }
 
   public void setUserName(String userName) {
      this.userName = userName;
   }
}
 
public class Test{ 
   //更改user中name的方法
   public static void replaceName(User u){ 
      //1
      u.setUserName("bbb");
 
      //2
      User u1 = new User();
      u1.setUserName("bbb");
      u=u1;  
      //3
      User u1=u;
      u1.setUserName("bbb");
   } 
    
   //main函数测试
   public static void main(String args[]){   
      User u= new User();
      u.setUserName("aaa");
      //调用函数更改user中的name
      replaceName(u);
      System.out.println(u.getUserName());
   } 
} 

//用1）代码输出"bbb"
//用2）代码输出"aaa"
//用3）代码输出"bbb"
//为什么？
答：参数是值传递~但是本处要考虑Java对象引用的概念。

在博客上看到一篇文章，写的不错，引用下吧：http://blog.csdn.net/niuniu20008/article/details/2953785 

许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。

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

 

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

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

下面看个小程序：

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);
18.         System.out.print(tt.str+" and ");
19.         System.out.println(tt.ch);     
20.     }
21. }

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

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

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

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

所以结果是：

10

good and gbc

现在咱们把代码变化一下：

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);
18.         System.out.print(tt.str+" and ");
19.         System.out.println(tt.ch);     
20.     }
21. }

仔细观察下实参以及入参有何变化？

change()方法里的入参char[] ch变成--------------char ch;

这次传递的是个char值的单个数组元素，按照上面的解析，此时ch='9';是不影响源数组元素的。

this.i = i+1;这里面等号左边的i是属性i，等号右边的i是局部变量（入参里的i）；

此时i+1后赋值给属性的i，自然会改变属性i的值，同时17行，tt.i又是调用属性的i，这次的结果是：

11

good and abc

现在是不是有点明白了？

那好再看下面一个小程序

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);   
14.     }
15. }

这次传递的是两个对象的引用的值，

在方法change()里 的x.append(y),     其中引用x调用api方法append()修改了new StringBuffer("a");的内容。

 y=x;是一个修改内容的对象把首地址赋值给引用变量y了，此时操作的是引用，而先前y是new StringBuffer("b");的引用变量，所以输出结果是：

ab,b

下面是个稍难的小程序，先自己用笔画画过程，写出自己的结果，而后再上机操作下，如果自己的结果和在电脑上的结果一样，那么再碰到这类题就不难了，如果不一样，回头仔细体会下我前面的讲解，找找原因。

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]);
13.         mm = new String[]{"8","7"};
14.         System.out.println("in test(),nn: "+nn);
15.         System.out.println("this.nn: "+this.nn);
16.         System.out.println("mm[0]: "+mm[0]);
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]);
24.     }
25. }