java中参数传递

时间：2021-12-25 21:27:19
总之一句话：java中只有副本传递，对于值，拷贝值，对于引用，拷贝引用（对于数组，数组名传递的都是引用）。 

   
   
   
    

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

    141.
ceshi1的输出： 
   
   
   
    

  1. A的对象a中i=1
    2. 
    
    
    
  2. A的对象a中s=I'll change you!
    3. 
    
    
    
    4. 
    
    
    
  4. 被传入并修改的i=1
    5. 
    
    
    
  5. 被传入并修改的s=I'll change you!
    6.
ceshi2的输出： 
    
    
    
    

  1. A的对象a中i=1
    2. 
     
     
     
  2. A的对象a中s=bbb
    3. 
     
     
     
    4. 
     
     
     
  4. A的对象a中b.index=2
    5. 
     
     
     
  5. A的对象a中b的hash值=2046587545
    6. 
     
     
     
    7. 
     
     
     
  7. 被传入的i=2
    8. 
     
     
     
  8. 被传入的s=I'll change you!But I have been changed too!
    9. 
     
     
     
  9. 被传入的b.index=2
    10. 
     
     
     
  10. 被传入的b的hash值=2046587545
    11.

ceshi3的输出： 
    
    
    
    

  1. A的对象a中ii=[I@62af9d74
    2. 
     
     
     
  2. A的对象a中ii[0]=1
    3. 
     
     
     
    4. 
     
     
     
  4. 被传入的intarray=[I@62af9d74
    5. 
     
     
     
  5. 被传入的intarray[0]=1
    6.


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

在执行94行语句的时候，同时改变了两个地方，说明this.b和b只是同一个实例对象的不同引用而已。它们内部的属性值是一样的。
java中参数传递
 




标签：

相关文章