JAVA中的传递都是值传递吗？有没有引用传递呢？.docx

JAVA中的传递都是值传递吗？有没有引用传递呢？ 

在回答这两个问题前，让我们首先来看一段代码： 
Java代码  
1. public final class ParamTest {  
2.     // 初始值为0  
3.     protected int num = 0;  
4.   
5.     // 为方法参数重新赋值  
6.     public void change(int i) {  
7.         i = 5;  
8.     }  
9.   
10.     // 为方法参数重新赋值  
11.     public void change(ParamTest t) {  
12.         ParamTest tmp = new ParamTest();  
13.         tmp.num = 9;  
14.         t = tmp;  
15.     }  
16.   
17.     // 改变方法参数的值  
18.     public void add(int i) {  
19.         i += 10;  
20.     }  
21.   
22.     // 改变方法参数属性的值  
23.     public void add(ParamTest pt) {  
24.         pt.num += 20;  
25.     }  
26.   
27.     public static void main(String[] args) {  
28.         ParamTest t = new ParamTest();  
29.   
30.         // 为基本类型参数重新赋值  
31.         t.change(t.num);  
32.         System.out.println(t.num);  
33.         // 为引用型参数重新赋值  
34.         t.change(t);  
35.         System.out.println(t.num);  
36.   
37.         // 改变基本类型参数的值  
38.         t.add(t.num);  
39.         System.out.println(t.num);  
40.         // 改变引用类型参数所指向对象的属性值  
41.         t.add(t);  
42.         System.out.println(t.num);  
43.     }  
44. }  

这段代码的运行结果如下： 

1. 0
2. 0
3. 0
4. 20

从上面这个直观的结果中我们很容易得出如下结论： 

1. 对于基本类型，在方法体内对方法参数进行重新赋值，并不会改变原有变量的值。
2. 对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。
3. 方法体内对参数进行运算，不影响原有变量的值。
4. 方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。

上面总结出来的不过是我们所看到的表面现象。那么，为什么会出现这样的现象呢？这就要说到值传递和引用传递的概念了。这个问题向来是颇有争议的。 

大家都知道，在JAVA中变量有以下两种： 

1. 基本类型变量，包括char、byte、short、int、long、float、double、boolean。
2. 引用类型变量，包括类、接口、数组（基本类型数组和对象数组）。

当基本类型的变量被当作参数传递给方法时，JAVA虚拟机所做的工作是把这个值拷贝了一份，然后把拷贝后的值传递到了方法的内部。因此在上面的例子中，在调用 
Java代码  
1. // 为方法参数重新赋值  
2. public void change(int i) {  
3.     i = 5;  
4. }  

方法的情况下，变量i和ParamTest型对象t的属性num具有相同的值，却是两个不同变量。变量i是由JAVA虚拟机创建的作用域在change(int i)方法内的局部变量，在这个方法执行完毕后，它的生命周期就结束了。在JAVA虚拟机中，它们是以类似如下的方式存储的： 

很明显，在基本类型被作为参数传递给方式时，是值传递，在整个过程中根本没有牵扯到引用这个概念。这也是大家所公认的。对于布尔型变量当然也是如此，请看下面的例子： 
Java代码  
1. public final class BooleanTest {  
2.     // 布尔型值  
3.     boolean bool = true;  
4.   
5.     // 为布尔型参数重新赋值  
6.     public void change(boolean b) {  
7.         b = false;  
8.     }  
9.   
10.     // 对布尔型参数进行运算  
11.     public void calculate(boolean b) {  
12.         b &= false;  
13.         // 为了方便对比，将运算结果输出  
14.         System.out.println("运算后的值：" + b);  
15.     }  
16.   
17.     public static void main(String[] args) {  
18.         BooleanTest t = new BooleanTest();  
19.   
20.         // 为布尔型参数重新赋值  
21.         t.change(t.bool);  
22.         System.out.println(t.bool);  
23.   
24.         // 改变布尔型参数的值  
25.         t.calculate(t.bool);  
26.         System.out.println(t.bool);  
27.     }  
28. }  

输出结果如下： 

1. true
2. 运算后的值：false
3. true

那么当引用型变量被当作参数传递给方法时JAVA虚拟机又是怎样处理的呢？同样，它会拷贝一份这个变量所持有的引用，然后把它传递给JAVA虚拟机为方法创建的局部变量，从而这两个变量指向了同一个对象。在篇首所举的示例中，ParamTest类型变量t和局部变量pt在JAVA虚拟机中是以如下的方式存储的： 

有一种说法是当一个对象或引用类型变量被当作参数传递时，也是值传递，这个值就是对象的引用，因此JAVA中只有值传递，没有引用传递。这种说法显然是混淆了值和引用的概念。 

值传递中的值指的是基本类型的数值，即使对于布尔型，虽然它的表现形式为true和false，但是在栈中，它仍然是以数值形式保存的，即0表示true，其它数值表示false。而引用是我们用来操作对象的工具，它包含了对象在堆中保存地址的信息。即使在被作为参数传递给方法时，实际上传递的是它的拷贝，但那仍是引用。 

最后我们得出如下的结论： 

1. 基本类型和基本类型变量被当作参数传递给方法时，是值传递。在方法实体中，无法给原变量重新赋值，也无法改变它的值。
2. 对象和引用型变量被当作参数传递给方法时，是引用传递。在方法实体中，无法给原变量重新赋值，但是可以改变它所指向对象的属性

引用传递扩展

java 中传值 * 传引用
分类： programming life java j2ee2012-07-08 23:17 565人阅读 评论(0) 收藏 举报
javastringhashmapclassiterator
（一）基本数据类型：传值，方法不会改变实参的值。
package com.jhl;
public class TestFun {
public static void testInt(int i){
i=5;
}
public static void main(String[] args) {
int a=0 ;
TestFun.testInt(a);
System.out.println("a="+a);
}
}
--打印结果:a=0
（二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。
　　举两个例子：
　　（1）方法体内改变形参引用，但不会改变实参引用 ，实参值不变。
package com.jhl;
public class Demo {

public void changeStr(String str){
str="jhl"; //形参引用指向字符串"jhl"
}
public static void main(String[] args){
String str="jihi";
new Demo().changeStr(str);
System.out.println(str); //实参引用未改变，值也没变
}
}
--打印结果:jihi
（2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。
package com.jhl;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test {
public void a(Map a, String b) {
a.put("test", b);
}
public void b() {
Map a = new HashMap();
a.put("test", "a");
String b = "b";
printMap(a);－－－－　key:test value:a
a(a, b); //改变了实参的内容
printMap(a);－－－－　key:test value:b
}
public <K, V> void printMap(Map a) {
Set set = a.entrySet();
Iterator it = set.iterator();
while (it.hasNext()) {
Map.Entry<K, V> e = (Map.Entry<K, V>) it.next();
System.out.println("key:" + e.getKey() + " value:" + e.getValue());
}
}
public static void main(String[] args) {
Test t = new Test();
t.b();
}
}
--打印结果:
key:test value:a
key:test value:b
（3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ：
public class TestFun { 
public static void testStringBuffer(StringBuffer sb){
sb.append("java");//改变了实参的内容 
} 
  public static void main(String[] args) { 
  StringBuffer sb= new StringBuffer("my ");
new TestFun().testStringBuffer(sb); 
System.out.println("sb="+sb.toString());//内容变化了 
} 
}

--打印结果:sb=my java
所以比较参数是String和StringBuffer 的两个例子就会理解什么是“改变实参对象内容”了
总结：
　　第一：java方法基本数据类型是传值，对象类型传引用，这是千真万确的。
　　第二：当参数是对象时，无论方法体内进行了何种操作，都不会改变实参对象的引用。
　　第三：当参数是对象时，只有在方法内部改变了对象的内容时，才会改变实参对象内容