注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

快乐的机器猫 大桥加加网易分站

要有更宽广的视野和胸怀

 
 
 

日志

 
 

JAVA传给方法的参数详解  

2012-05-15 09:18:34|  分类: 计算机软件学习 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

Java参数按值传递

转贴自百度文库:

http://wenku.baidu.com/view/77f67efbfab069dc5022019c.html


面试题:当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递
    :是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变,但对象的引用(不是引用的副本)是永远不会改变的。

-------------------------------------------------------------

在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用传递对象。但重要的是要区分参数是如何传递的,这才是该节选的意图。Java 应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用,而 Java 应用程序是按值传递对象引用的。 
   
Java 应用程序中的变量可以为以下两种类型之一:引用类型或基本类型。当作为参数传递给一个方法时,处理这两种类型的方式是相同的。两种类型都是按值传递的;没有一种按引用传递。 
    
按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本。因此,如果函数修改了该参数,仅改变副本,而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。因此,如果函数修改了该参数的值,调用代码中的原始值也随之改变。如果函数修改了该参数的地址,调用代码中的原始值不会改变.
    
当传递给函数的参数不是引用时,传递的都是该值的一个副本(按值传递)。区别在于引用。在 C++ 中当传递给函数的参数是引用时,您传递的就是这个引用,或者内存地址(按引用传递)。在 Java 应用程序中,当对象引用是传递给方法的一个参数时,您传递的是该引用的一个副本(按值传递),而不是引用本身。 
    
Java 应用程序按值传递参数(引用类型或基本类型),其实都是传递他们的一份拷贝.而不是数据本身.(不是像 C++ 中那样对原始值进行操作。) 


1:

Java代码 JAVA传给方法的参数详解 - huasoft - 快乐的机器猫 小桥加加网易分站

1. //在函数中传递基本数据类型,   

2. public class Test {   

3.             

4.     public static void change(int i, int j) {   

5.         int temp = i;   

6.         i = j;   

7.         j = temp;   

8.     }   

9.   

10.     public static void main(String[] args) {   

11.         int a = 3;   

12.         int b = 4;   

13.         change(a, b);   

14.   

15.         System.out.println("a=" + a);   

16.         System.out.println("b=" + b);   

17.     }   

18. }   

19.   

20. 结果为:   

21. a=3  

22. b=4  

23. 原因就是 参数中传递的是 基本类型 a  b 的拷贝,在函数中交换的也是那份拷贝的值 而不是数据本身;   

 

2:

Java代码 JAVA传给方法的参数详解 - huasoft - 快乐的机器猫 小桥加加网易分站

1. //传的是引用数据类型   

2. public class Test {   

3.   

4.     public static void change(int[] counts) {   

5.         counts[0] = 6;   

6.         System.out.println(counts[0]);   

7.     }   

8.   

9.     public static void main(String[] args) {   

10.         int[] count = { 12345 };   

11.         change(count);   

12.     }   

13. }   

14.   

15. 在方法中 传递引用数据类型int数组,实际上传递的是其引用count的拷贝,他们都指向数组对象,在方法中可以改变数组对象的内容。即:对复制的引用所调用的方法更改的是同一个对象。  



3:

Java代码 JAVA传给方法的参数详解 - huasoft - 快乐的机器猫 小桥加加网易分站

1. //对象的引用(不是引用的副本)是永远不会改变的   

2. class A {   

3.     int i = 0;   

4. }   

5.   

6.   

7. public class Test {   

8.   

9.     public static void add(A a) {   

10.         a = new A();   

11.         a.i++;   

12.     }   

13.        

14.     public static void main(String args[]) {   

15.         A a = new A();   

16.         add(a);   

17.         System.out.println(a.i);   

18.     }   

19. }   

20.   

21. 输出结果是0  

22. 在该程序中,对象的引用指向的是A ,而在add方法中,传递的引用的一份副本则指向了一个新的OBJECT,并对其进行操作。   

23. 而原来的A对象并没有发生任何变化。 引用指向的是还是原来的A对象。  




4: 
String 不改变,数组改变

Java代码 JAVA传给方法的参数详解 - huasoft - 快乐的机器猫 小桥加加网易分站

1.   

2. public class Example {   

3.     String str = new String("good");   

4.   

5.     char[] ch = { 'a''b''c' };   

6.   

7.     public static void main(String args[]) {   

8.         Example ex = new Example();   

9.         ex.change(ex.str, ex.ch);   

10.         System.out.print(ex.str + " and ");   

11.         System.out.println(ex.ch);   

12.     }   

13.   

14.     public void change(String str, char ch[]) {   

15.         str = "test ok";   

16.         ch[0] = 'g';   

17.     }   

18. }    

19. 程序3输出的是 good and gbc.   

20. String 比较特别,看过String 代码的都知道, String  final的。所以值是不变的。 函数中String对象引用的副本指向了另外一个新String对象,而数组对象引用的副本没有改变,而是改变对象中数据的内容.   

21. 对于对象类型,也就是Object的子类,如果你在方法中修改了它的成员的值,那个修改是生效的,方法调用结束后,它的成员是新的值,但是如果你把它指向一个其它的对象,方法调用结束后,原来对它的引用并没用指向新的对象。 

/********************************************************************************/

Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)

    如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的 值不会改变原始的值.

    如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的地址,所以不会改变参数的值。

 ( 对象包括对象引用即地址和对象的内容)

 

a.传递值的数据类型:八种基本数据类型和String(这样理解可以,但是事实上String也是传递的地址,只是string对象和其他对象是不同的,string对象是不能被改变的,内容改变就会产生新对象。那么StringBuffer就可以了,但只是改变其内容。不能改变外部变量所指向的内存地址)


b.传递地址值的数据类型:除String以外的所有复合数据类型,包括数组、类和接口



========================================================
附:聊天记录
public void change(String str, char ch[]) {   

15.         str = "test ok";   

16.         ch[0] = 'g';   

17.     }   
青岛-大桥(27420690)  9:32:22
考考大家哈, 这个函数里 str 被修改后, 在函数体外是否也被修改了?
一会儿揭晓答案哈
环境: JAVA
不是C/C++
北京-Touch(461649731)  9:33:29
改了
青岛-大桥(27420690)  9:33:41
请回答为什么改了?
北京-Touch(461649731)  9:34:00
引用传递
青岛-大桥(27420690)  9:34:03
因为参数是传递引用? 所以改了?
北京-Touch(461649731)  9:34:20

青岛-大桥(27420690)  9:34:24
那请你在自己电脑上做个小实验,看到底是改了没改, 实际应该是:没有改!
2. public class Example {   

3.     String str = new String("good");   

4.   

5.     char[] ch = { 'a', 'b', 'c' };   

6.   

7.     public static void main(String args[]) {   

8.         Example ex = new Example();   

9.         ex.change(ex.str, ex.ch);   

10.         System.out.print(ex.str + " and ");   

11.         System.out.println(ex.ch);   

12.     }   

13.   

14.     public void change(String str, char ch[]) {   

15.         str = "test ok";   

16.         ch[0] = 'g';   

17.     }   

18. }    
北京-Touch(461649731)  9:34:48
我 用 对象 试过 改了
 西安-天天向上(331017613)  9:35:09
JAVA传给方法的参数详解 - huasoft - 快乐的机器猫 小桥加加网易分站
青岛-大桥(27420690)  9:35:19
一般的对象 当引用传递进 函数方法,都会被改。

但是String很特殊
河南-jacky(805260758)  9:35:46
String 是final的
青岛-大桥(27420690)  9:35:57
jacky正解
不过我不太明白, final就可以让编译器换了一种对参数的解释方法吗?
这点jacky明了不?
北京-Touch(461649731)  9:36:48
char[] 为什么呢
也不变呢
青岛-大桥(27420690)  9:37:18
char[]这个 在函数体外也被修改了
北京-Touch(461649731)  9:37:40
final 是 不让你改值 
青岛-大桥(27420690)  9:37:39
只是String str没被修改, 在函数体内有一个新的副本了
北京-Touch(461649731)  9:38:05
一开始 赋的是什么 就是 什么
青岛-大桥(27420690)  9:38:39
我本以为 “final 是 不让你改值 ” 这项 , 
会是在编译器提示类似这样的内容
final param cannot be changed...

结果呢,它直接生成一新副本,而不是提示编译错误

北京-Touch(461649731)  9:39:58
啥意思
青岛-大桥(27420690)  9:41:09
你看在C++ 里,如果传递的参数加上个 const, 如果你修改了它,它会报编译错误吧
北京-Touch(461649731)  9:41:39
你是说 不报错 是吧
青岛-大桥(27420690)  9:42:13
嗯嗯,它不报错,它直接隐式的利用传进来的这个 引用副本,生成并指向新的对象空间
貌似JAVA挺智能
北京-Touch(461649731)  9:42:41
你跟进去看了?
青岛-大桥(27420690)  9:42:49
没有跟
不过表面事实上,它的确没有修改String的内容
青岛-大桥(27420690)  9:44:03
这样似乎只能解释说 它这个  str = "test ok";   在另一块内存中 生成 了对象包含“ test ok” 这些内容
北京-Touch(461649731)  9:44:53
是么 又生成新对象了么?
青岛-大桥(27420690)  9:45:17
... 这个我不确定。。。

北京-Touch(461649731)  9:45:29
我的理解是 str指向的 空间  就是不让改
青岛-大桥(27420690)  9:46:22
是的, 除了初始化之外,不让改。

那么 str = "test ok" 这里的 “test ok”存在哪里, 一定不是存在当初定义的String str = new String("good"); 这里
北京-Touch(461649731)  9:47:24
是不 就没存那
忽略了
青岛-大桥(27420690)  9:48:14
那我打印一下试试
北京-Touch(461649731)  9:50:32
应该 是重新  复制了 一个str对象 和外边的不是一个了
青岛-大桥(27420690)  9:52:53
我刚试了,没改到外层

来看代码片段:
public static void changestr(String str)
{
str = "have changed...";
System.out.println("str's copy is:" + str);
}

//------------
String mystr = "orinal string";
changestr(mystr);
System.out.println("mystr is:" + mystr);
//=============================
结果打印输出:
str's copy is:have changed...
mystr is:orinal string
  评论这张
 
阅读(921)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017