Java深入学习系列之值传递Or引用传递？

 我们来看一个新手甚至写了多年Java的朋友都可能不是十分确定的问题：

目前创新互联建站已为近千家的企业提供了网站建设、域名、网页空间、网站托管运营、企业网站设计、象山网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

在Java方法传参时，究竟是引用传递还是值传递?

为了说明问题， 我给出一个非常简单的class定义：

 
 
    
  
  
  1. public class Foo { 
    2. 
  
  
  2.   String attribute; 
    3. 
  
  
  3.   Foo(String s) { 
    4. 
  
  
  4.     this.attribute = s; 
    5. 
  
  
  5.   } 
    6. 
  
  
  6.   void setAttribute(String s) { 
    7. 
  
  
  7.     this.attribute = s; 
    8. 
  
  
  8.   } 
    9. 
  
  
  9.   String getAttribute() { 
    10. 
  
  
  10.     return this.attribute; 
    11. 
  
  
  11.   } 
    12. 
  
  
  12. }  
    13.

下面在阐明观点时，可能会多次用到该类。

关于Java里值传递还是引用传递，至少从表现形式上来看，两种观点都有支撑的论据。下面我来一一分析：

观点1：引用传递

理由如下：先看一段代码

 
 
    
  
  
  1. public class Main { 
    2. 
  
  
  2.   public static void modifyReference(Foo c){ 
    3. 
  
  
  3.     c.setAttribute("c"); // line DDD 
    4. 
  
  
  4.   } 
    5. 
  
  
  5.  
    6. 
  
  
  6.   public static void main(String[] args) { 
    7. 
  
  
  7.     Foo fooRef = new Foo("a"); // line AAA 
    8. 
  
  
  8.     modifyReference(fooRef); // line BBB 
    9. 
  
  
  9.     System.out.println(fooRef.getAttribute()); // 输出 c 
    10. 
  
  
  10.   } 
    11. 
  
  
  11. }  
    12.

上述示例，输出结果为"c"，而不是"c"。

我们在line AAA处新创建了一个Object Foo并将其引用fooRef在line BBB处传给了方法modifyReference()的参数cRef, 该方法内部处理后，fooRef指向的Object中的值从"a"变成了"c", 而引用fooRef还是那个引用， 因此，我们是否可以认为，在line BBB处发生了引用传递?

先留着疑问，我们继续往下看。

观点2：值传递

继续看一段代码

 
 
    
  
  
  1. public class Main { 
    2. 
  
  
  2.   public static void changeReference(Foo aRef){ 
    3. 
  
  
  3.     Foo bRef = new Foo("b"); 
    4. 
  
  
  4.     aRef = bRef;   // line EEE 
    5. 
  
  
  5.   } 
    6. 
  
  
  6.    
    7. 
  
  
  7.   public static void main(String[] args) { 
    8. 
  
  
  8.     Foo fooRef = new Foo("a"); // line AAA 
    9. 
  
  
  9.     changeReference(fooRef); // line BBB 
    10. 
  
  
  10.     System.out.println(fooRef.getAttribute()); // 输出 a 
    11. 
  
  
  11.   } 
    12. 
  
  
  12. }  
    13.

上述示例，输出结果为"a"， 而不是"b"。

我们在line AAA处新创建了一个Object Foo并将其引用fooRef在line EEE处传给了方法changeReference()的参数aRef, 该方法内部引用aRef在line DDD处被重新赋值。如果是引用传递，那么引用aRef在line EEE处已经被指向了新的Object, 输出应该为"b"才对，事实上是怎样的呢?事实上输出了"b",也就是说changeReference()方法改变了传入引用所指对象的值。

观点1和观点2的输出结果多少会让人有些困惑，别急，我们继续往下看。

深入分析

为了详细分析这个问题，把上述两段代码合起来：

 
 
    
  
  
  1. public class Main { 
    2. 
  
  
  2.   public static void modifyReference(Foo cRef){ 
    3. 
  
  
  3.     cRef.setAttribute("c"); // line DDD 
    4. 
  
  
  4.   } 
    5. 
  
  
  5.   public static void changeReference(Foo aRef){ 
    6. 
  
  
  6.     Foo bRef = new Foo("b"); // line FFF 
    7. 
  
  
  7.     aRef = bRef;   // line EEE 
    8. 
  
  
  8.   } 
    9. 
  
  
  9.    
    10. 
  
  
  10.   public static void main(String[] args) { 
    11. 
  
  
  11.     Foo fooRef = new Foo("a"); // line AAA 
    12. 
  
  
  12.     changeReference(fooRef); // line BBB 
    13. 
  
  
  13.     System.out.println(fooRef.getAttribute()); // 输出 a 
    14. 
  
  
  14.      
    15. 
  
  
  15.     modifyReference(fooRef); // line CCC 
    16. 
  
  
  16.     System.out.println(fooRef.getAttribute()); // 输出 c 
    17. 
  
  
  17.      
    18. 
  
  
  18.  
    19. 
  
  
  19.   } 
    20. 
  
  
  20. }  
    21.

下面来深入内部来详细分析一下引用和Object内部的变化。来看下面图示：

① Line AAA, 申明一个名叫fooRef，类型为Foo的引用，并见其分配给一个新的包含属性值为"f"的对象，该对象类型为Foo。

 
 
    
  
  
  1. Foo fooRef = new Foo("a"); // line AAA 
    2.

 ② Line DDD, 方法内部，申明了一个Foo类型的名为aRef的引用，且aRef被初始化为null。

 
 
    
  
  
  1. void changeReference(Foo a); 
    2.

③ Line CCC, changeReference()方法被调用后，引用aRef被分配给fooRef指向的对象。

 
 
    
  
  
  1. changeReference(fooRef); 
    2.

 ④ Line FFF, 申明一个名叫bRef，类型为Foo的引用，并见其分配给一个新的包含属性值为"b"的对象，该对象类型为Foo。

 
 
    
  
  
  1. Foo bRef = new Foo("b"); 
    2.

 ⑤ Line EEE, 将引用aRef重新分配给了包含属性"b"的对象。此处注意，并非将fooRef重新分配，而是aRef。

 
 
    
  
  
  1. aRef = bRef; 
    2.

 ⑥ Line CCC, 调用方法modifyReference(Foo cRef)后，新建了一个引用cRef并将之分配到包含该属性"f"的对象上，该对象同时被两个引用fooRef和cRef指向着。

 
 
    
  
  
  1. modifyReference(fooRef);  
    2.

 ⑦ Line DDD, cRef.setAttribute("c");将会改变cRef引用指向的包含属性"f"的对象，而该对象同时被引用fooRef指向着。

 
 
    
  
  
  1. cRef.setAttribute("c"); 
    2.

 此时引用fooRef指向的对象内部属性值"f"也被重新设置为"c"。

总结

Java内部方法传参不是引用传递，而是引用本身的"值"的传递，归根结底还是值传递。将一个对象的引用fooRef传给方法的形参newRef，将给该对象新增了一个引用，相当于多了一个alias。我们可以通过这个原引用fooRef，或这是方法参数里的新引用newRef去访问、操作原对象，也可以改变参数里的引用newRef本身的值，却无法改变原引用fooRef的值。

网页名称：Java深入学习系列之值传递Or引用传递？
本文URL：http://www.mswzjz.com/qtweb/news36/203186.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

行业网站建设

注册域名　　 　微信服务号订阅号开发　　 　光华机房服务器托管　　 　高端网站建设　　 　软文平台　　 　平城网站运维　　 　雅安服务器托管　　 　定制网站设计　　 　商标注册　　 　成都定制网站建设　　 　甘孜州博瑞斯　　 　注册域名　　 　棕树数据中心　　 　成都电信服务器托管　　 　企业网站建设公司　　 　固迪佳新材料　　 　成都商城app开发　　 　成都网站设计　　 　川银永信　　 　重庆网站建设