java参数传递还是引用传递

[java] view plaincopyprint?

1. 什么是值传递?什么是引用传递?  
2.   
3. 值传递是将要传递的值作为一副本传递.如   
4. int i=4;  
5. int j=i;  
6. 这里相当于把14复制了一个副本给j,结果是i=4,j=4  

 

引用传递,传递的是引用对象的内存地址
int *p,*p1;
int j=5; *p=j; //这里是把j在内存当中的地址赋给了指针p
p1=p; //这里是把指针p中保存的地址(就是j的地址)赋给了指针p1
j=4; //这里改变j的值 输出结果是 j=4 , *p=4 , *p1=4 //因为p和p1指向的都是j 所以他们的值随j值改变
(以上说明和代码来自http://zhidao.baidu.com/question/31191252.html)

Java中函数参数的传递是值传递还是引用传递？

Java中参数传递时传递到函数中的参数都是原变量的一份拷贝，对于非类类型如int，float等，这份拷贝自然和原变量脱离了关系，这不难理解；
而对于类的实例而言，这份拷贝恰巧是实例引用的拷贝，它（参数）指向的实例地址和原实例引用指向的实例地址都是一样的，因此对参数的修改有时也会影响到实 例本身，故此造成了Java传递类实例是传递的引用即地址的假象，如下面例子中的changeMemberField函数，但是我们把参数指向的地址改到 别的实例上时，如changeMember函数，我们会发现参数和原实例引用再也不会发生关系了，这里证明Java中参数传递是完完全全是传值而不是传 址。

例子代码：

代码：

 

[java] view plaincopyprint?

1. package com.sitinspring;  
2.   
3. public class ChangeClass{  
4.     public void changeInt(int i){  
5.         i=5;  
6.     }  
7.       
8.     public void changeLong(long i){  
9.         i=555;  
10.     }  
11.       
12.     public void changeString(String str){  
13.         str="5555";  
14.     }  
15.       
16.     public void changeMember(Member member){  
17.         member=new Member("Cindy",35);  
18.     }  
19.       
20.     public void changeMemberField(Member member){  
21.         member.setAge(20);  
22.         member.setName("Andy");  
23.     }  
24.       
25.     public static void main(String[] args){  
26.         ChangeClass changeClass=new ChangeClass();  
27.           
28.         int intValue=10;  
29.         changeClass.changeInt(intValue);  
30.         System.out.println(intValue);  
31.           
32.         long longValue=10;  
33.         changeClass.changeLong(longValue);  
34.         System.out.println(longValue);  
35.           
36.         String stringValue="1234";  
37.         changeClass.changeString(stringValue);  
38.         System.out.println(stringValue);          
39.           
40.         Member member2=new Member("Douglas",45);  
41.         changeClass.changeMember(member2);  
42.         System.out.println(member2);  
43.           
44.         Member member=new Member("Bill",25);  
45.         changeClass.changeMemberField(member);  
46.         System.out.println(member);  
47.     }  
48. }  

 

[java] view plaincopyprint?

1. package com.sitinspring;  
2.   
3. public class Member{  
4.     private String name;  
5.     private int age;  
6.       
7.     public Member(String name,int age){  
8.         this.age=age;  
9.         this.name=name;  
10.     }  
11.       
12.     public String toString(){  
13.         return "Member name="+name+" age="+age;  
14.     }  
15.   
16.     public int getAge() {  
17.         return age;  
18.     }  
19.   
20.     public void setAge(int age) {  
21.         this.age = age;  
22.     }  
23.   
24.     public String getName() {  
25.         return name;  
26.     }  
27.   
28.     public void setName(String name) {  
29.         this.name = name;  
30.     }      
31. }  

输出：

10
10
1234
Member name=Douglas age=45
Member name=Andy age=20

 

 

解释：
第一个输出10是因为int是基本类型,传递的参数是intValue的拷贝,对拷贝的修改对原值intValue没有影响.
第一个输出10和上面是一个道理.
第三个输出1234.由于String是类类型, str是stringValue的地址拷贝,参数str指向的地址和stringValue的一致,但在函数changeString 中,由于String的特殊性, str=“5555”和str=new String(“5555”)是等价的, str指向了新的”5555”所在的地址,此句后str就与原来的stringValue彻底脱离了联系.
第四个输出Member?name=Douglas?age=45的道理和上面相同.
第五个输出Member?name=Andy?age=20是因为changeMemberField函数中修改了参数member 的值,也就是修改member指向实例的值,而这个实例正是member指向的值,因此member就变成了name=Andy 且age=20.

结论

Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.
对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改.