首页 > 代码库 > java中参数传递

java中参数传递

总之一句话:java中只有副本传递,对于值,拷贝值,对于引用,拷贝引用(对于数组,数组名传递的都是引用)。

  1. /**
  2. * java中只有副本传递,对于值,拷贝值,对于引用,拷贝引用(对于数组,数组名传递的都是引用)。
  3. * @author sargeles
  4. */
  5. public class About_Onlyvaluetransmit {
  6. /**
  7. * 测试一组:基本类型传递是按值传递,意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本。
  8. * String因为两个原因表现出基本类型的特征: 一个是String实际上操作的是char[],可以理解为String是char[]的包装类
  9. * 二是给String变量重新赋值后,实际上没有改变这个变量的值,而是重新new了一个String对象,这里涉及到String不可变这一特性。
  10. */
  11. static void ceshi1() {
  12. int i = 1;
  13. String s = new String("I‘ll change you!");
  14. A a = new A();
  15. a.change(i, s);
  16. a.show();
  17. System.out.println("被传入并修改的i=" + i);
  18. System.out.println("被传入并修改的s=" + s);
  19. }
  20. /**
  21. * 测试二组:引用类型传递是副本传递,意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。
  22. * 但需要注意到的是,ceshi2里定义的b,会被直接传递给a,作为a的属性,而不是复制给a,
  23. * 也就是说对象b并不会被拷贝,对change()传递参数后,A.b与b指向同一个对象。 也是遵循‘引用传递’这四个字。
  24. */
  25. static void ceshi2() {
  26. int[] intarray = { 0, 1, 2 };
  27. String[] strarray = { "aaa", "bbb", "ccc" };
  28. A a = new A();
  29. B b = new B(1);
  30. a.change(intarray, strarray, b);
  31. a.show();
  32. System.out.println("被传入的i=" + intarray[1]);
  33. System.out.println("被传入的s=" + strarray[1]);
  34. System.out.println("被传入的b.index=" + b.index);
  35. System.out.println("被传入的b的hash值=" + b.hashCode());
  36. }
  37. /**
  38. * 为了进一步证实ceshi2中的引用传递,这次我们测试的是数组的引用,而不是对象的引用。
  39. */
  40. static void ceshi3() {
  41. int[] intarray = { 0, 1, 2 };
  42. A a = new A();
  43. a.change(intarray);
  44. a.show();
  45. System.out.println("被传入的intarray=" + intarray);
  46. System.out.println("被传入的intarray[0]=" + intarray[0]);
  47. }
  48. public static void main(String[] args) {
  49. ceshi1();
  50. //ceshi2();
  51. // ceshi3();
  52. }
  53. }
  54. class A {
  55. int i = 0;
  56. int[] ii = { 0, 1, 2 };
  57. String s = "I‘m not changed!";
  58. B b = new B(0);
  59. /**
  60. * ceshi1专用
  61. */
  62. void change(int i, String s) {
  63. this.i = i;
  64. i++;
  65. this.s = s;
  66. s = "I‘ll change you!But I have been changed too!";
  67. }
  68. /**
  69. * ceshi2专用
  70. */
  71. void change(int[] i, String[] s, B b) {
  72. this.i = i[1];
  73. i[1]++;
  74. this.s = s[1];
  75. s[1] = "I‘ll change you!But I have been changed too!";
  76. this.b = b;
  77. // 下面的语句改为 this.b.index++; 效果不变。
  78. b.index++;
  79. }
  80. /**
  81. * ceshi3专用
  82. */
  83. public void change(int[] intarray) {
  84. this.ii = intarray;
  85. intarray[0]++;
  86. }
  87. public void show() {
  88. if (i != 0)
  89. System.out.println("A的对象a中i=" + i);
  90. if (ii[0] != 0) {
  91. System.out.println("A的对象a中ii=" + ii);
  92. System.out.println("A的对象a中ii[0]=" + ii[0]);
  93. }
  94. if (!s.equals("I‘m not changed!"))
  95. System.out.println("A的对象a中s=" + s);
  96. System.out.println();
  97. try {
  98. if (b.index != 0) {
  99. System.out.println("A的对象a中b.index=" + b.index);
  100. System.out.println("A的对象a中b的hash值=" + b.hashCode());
  101. System.out.println();
  102. }
  103. } catch (java.lang.NullPointerException e) {
  104. System.out.println("未得到B对象!");
  105. }
  106. }
  107. }
  108. class B {
  109. int index = 0;
  110. public B(int i) {
  111. index = i;
  112. }
  113. }

ceshi1的输出:
  1. A的对象ai=1
  2. A的对象as=Ill change you!
  3. 被传入并修改的i=1
  4. 被传入并修改的s=I‘ll change you!
ceshi2的输出:
  1. A的对象ai=1
  2. A的对象as=bbb
  3. A的对象ab.index=2
  4. A的对象abhash值=2046587545
  5. 被传入的i=2
  6. 被传入的s=Ill change you!But I have been changed too!
  7. 被传入的b.index=2
  8. 被传入的bhash值=2046587545

ceshi3的输出:
  1. A的对象aii=[I@62af9d74
  2. A的对象aii[0]=1
  3. 被传入的intarray=[I@62af9d74
  4. 被传入的intarray[0]=1


关于引用传递,如果还看不懂,不妨继续看下去。
在ceshi2中,执行第92行语句的之前,两个b是不同的id,一个是25,一个是21,说明是不同的实例。
技术分享
执行后,可以看到两者变为同一id,说明引用被拷贝并传递了,现在已经没有引用指向B的id为25的实例
 技术分享

在执行94行语句的时候,同时改变了两个地方,说明this.b和b只是同一个实例对象的不同引用而已。它们内部的属性值是一样的。
技术分享
 


来自为知笔记(Wiz)


java中参数传递