java 传址或传值

 

原文链接: http://blog.csdn.net/jdluojing/article/details/6962893

java是传值还是传址,这个问题已经讨论了很久了,有些人说是传值的,有些人说要看情况,有些情况是传值,有些情况是传址。到底是传值还是传址呢?我们暂时先把传址理解为C++的传指针一样.....

先看下面一段程序:

 

  1. package luojing;  
  2. public class StringDemo  
  3. {  
  4.     public static void main(String[]args)  
  5.     {  
  6.         String str=new String("hello");  
  7.         //调用函数改变str的值  
  8.         change(str);  
  9.         System.out.println(str);  
  10.           
  11.     }  
  12.       
  13.     public static void change(String str1)  
  14.     {  
  15.         str1+="luojing";  
  16.     }  
  17. }  

程序执行结果: hello

 

      可以看到str的值并没有改变,String类型虽然是对象,但是其是常量,故传递的地址也就相当于常量指针const int*p=a;我们可以改变p的指向,但是不能改变*P(即a)的内容。在java中,当我们改变字符串常量str的值的时侯实际上是新创建了一个String对象,然后将新建对象的地址赋值给str1,所以我们只是改变了str1所指向的地址,并没有改变str1原来指向地址处的内容。并且我们在向change()参数传址的时候,传递的是str地址的一个拷贝,也就是相当于传递的是一个新的指向str所指向地址的指针str1,而我们在change()函数更改的只是我们传递的那个指针str1,对真实的str地址是没有影响的。所以当我们输出str时,它的值还是hello。

我们现在将上面程序中的String换成StringBuffer在来试试:

 

  1. public class StringDemo  
  2. {  
  3.     public static void main(String[]args)  
  4.     {  
  5.         StringBuffer str=new StringBuffer("hello");  
  6.         //调用函数改变str的值  
  7.         change(str);  
  8.         System.out.println(str);  
  9.           
  10.     }  
  11.       
  12.     public static void change(StringBuffer str1)  
  13.     {  
  14.         str1.append("luojing");  
  15.     }  
  16. }  


程序运行结果:hello luojing       这个时候str的内容就改变了。

 

我们再将上面的StringBuffer换成我们自己定义的对象:

 

  1. public class test  
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         Demo demo=new Demo("hello");  
  6.         //调用函数该变demo.name的值  
  7.         change(demo);  
  8.         System.out.println(demo.getName());  
  9.       
  10.     }  
  11.       
  12.     public static void change(Demo d)  
  13.     {  
  14.         d.setName("luojing");  
  15.     }  
  16.   
  17. }  
  18.   
  19. class Demo  
  20. {  
  21.     private String name;  
  22.       
  23.     public Demo(String s)  
  24.     {  
  25.         name=s;  
  26.     }  
  27.     public String getName()  
  28.     {  
  29.         return name;  
  30.     }  
  31.     public void setName(String str)  
  32.     {  
  33.         name=str;  
  34.     }  
  35. }  

程序运行结果: luojing  和我们使用StringBuffer对象是效果相同。

 

我们再对change()方法做一些修改:

 

  1. package luojing;  
  2. public class test   
  3. {  
  4.     public static void main(String[] args)   
  5.     {  
  6.         Demo demo=new Demo("hello");  
  7.         //调用函数该变demo.name的值  
  8.         change(demo);  
  9.         System.out.println(demo.getName());  
  10.       
  11.     }  
  12.       
  13.     public static void change(Demo d)  
  14.     {  
  15.         Demo d1=new Demo("hello java");  
  16.         d=d1;     
  17.     }  
  18.   
  19. }  
  20.   
  21. class Demo  
  22. {  
  23.     private String name;  
  24.       
  25.     public Demo(String s)  
  26.     {  
  27.         name=s;  
  28.     }  
  29.     public String getName()  
  30.     {  
  31.         return name;  
  32.     }  
  33.     public void setName(String str)  
  34.     {  
  35.         name=str;  
  36.     }  
  37. }  

运行结果:hello
     可以看到,虽然我们在change()方法中对d进行了改变,而实际的对象demo并没有改变。

 

     由此可见,java中所谓的“传址”其实也是一种传值(或者说java中没有传址)。我们给方法“传址”时实际上是传递的是实参的地址的一个拷贝,它跟我们的实参(这里把他们暂时都理解为指针)所指向的地址虽然相同,但他们却是两个不同的实体。所以当我们在方法中对形参进行重新赋值时,改变的只是形参所指向的地址,而实参所指向的地址没有被改变,所以其内容不变。

 

posted @ 2015-08-29 22:41  huhu0013  阅读(481)  评论(0编辑  收藏  举报