学过编程的都知道，在其他语言中都有诸如指针，引用传递来实现对函数实参里值的修改，但是在java中，既没有指针，又没有引用传递，那么java参数传递是怎么工作的呢？我们能否对其中的值进行修改呢？java中只有值传递,这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递，可能说的不是很清楚，下面给出一个完整的能说明情况的例子吧

1. package test;
   
2. 
   
3. /**
   
4. * @description Java中没有引用传递只有值传递
   
5. */
   
6. class Person {
   
7. 
   
8.     private String name;
   
9. 
   
10.     private String sex;
    
11. 
    
12.     public Person(String x, String y) {
    
13.         this.name = x;
    
14.         this.sex = y;
    
15.     }
    
16. 
    
17.     // 重写toString()方法，方便输出
    
18.     public String toString() {
    
19. 
    
20.         return name + " " + sex;
    
21.     }
    
22. 
    
23.     // 交换对象引用
    
24.     public static void swapObject(Person p1, Person p2) {
    
25.         Person tmp = p1;
    
26.         p1 = p2;
    
27.         p2 = tmp;
    
28.     }
    
29. 
    
30.     // 交换基本类型
    
31.     public static void swapInt(int a, int b) {
    
32.         int tmp = a;
    
33.         a = b;
    
34.         b = tmp;
    
35.     }
    
36. 
    
37.     // 交换对象数组
    
38.     public static void swapObjectArray(Person[] p1, Person[] p2) {
    
39.         Person[] tmp = p1;
    
40.         p1 = p2;
    
41.         p2 = tmp;
    
42.     }
    
43. 
    
44.     // 交换基本类型数组
    
45.     public static void swapIntArray(int[] x, int[] y) {
    
46.         int[] tmp = x;
    
47.         x = y;
    
48.         y = tmp;
    
49.     }
    
50. 
    
51.     // 改变对象数组中的内容
    
52.     public static void changeObjectArray(Person[] p1, Person[] p2) {
    
53.         Person tmp = p1[1];
    
54.         p1[1] = p2[1];
    
55.         p2[1] = tmp;
    
56.         
    
57.         // 再将p1[1]修改
    
58.         Person p = new Person("wjl", "male");
    
59.         p1[1] = p;
    
60.     }
    
61. 
    
62.     // 改变基本类型数组中的内容
    
63.     public static void changeIntArray(int[] x, int[] y) {
    
64.         int tmp = x[1];
    
65.         x[1] = y[1];
    
66.         y[1] = tmp;
    
67. 
    
68.         x[1] = 5;
    
69.     }
    
70. }
    
71. 
    
72. public class ByValueTest {
    
73. 
    
74.     public static void main(String[] args) {
    
75. 
    
76.         // 建立并构造两个对象
    
77.         Person p1 = new Person("Alexia", "female");
    
78.         Person p2 = new Person("Edward", "male");
    
79. 
    
80.         System.out.println("对象交换前：p1 = " + p1.toString());
    
81.         System.out.println("对象交换前：p2 = " + p2.toString());
    
82.         
    
83.         // 交换p1对象和p2对象
    
84.         Person.swapObject(p1, p2);
    
85.         // 从交换结果中看出，实际对象并未交换
    
86.         System.out.println("\n对象交换后：p1 = " + p1.toString());
    
87.         System.out.println("对象交换后：p2 = " + p2.toString());
    
88. 
    
89.         // 建立两个对象数组
    
90.         Person[] arraya = new Person[2];
    
91.         Person[] arrayb = new Person[2];
    
92. 
    
93.         // 分别构造数组对象
    
94.         arraya[0] = new Person("Alexia", "female");
    
95.         arraya[1] = new Person("Edward", "male");
    
96.         arrayb[0] = new Person("jmwang", "female");
    
97.         arrayb[1] = new Person("hwu", "male");
    
98. 
    
99.         System.out.println('\n' + "对象数组交换前：arraya[0] = "
    
100.                 + arraya[0].toString() + ", arraya[1] = "
     
101.                 + arraya[1].toString());
     
102.         System.out.println("对象数组交换前：arrayb[0] = "
     
103.                 + arrayb[0].toString() + ", arrayb[1] = "
     
104.                 + arrayb[1].toString());
     
105.         
     
106.         // 交换这两个对象数组
     
107.         Person.swapObjectArray(arraya, arrayb);
     
108.         System.out.println('\n' + "对象数组交换后：arraya[0] = "
     
109.                 + arraya[0].toString() + ", arraya[1] = "
     
110.                 + arraya[1].toString());
     
111.         System.out.println("对象数组交换后：arrayb[0] = "
     
112.                 + arrayb[0].toString() + ", arrayb[1] = "
     
113.                 + arrayb[1].toString());
     
114. 
     
115.         // 建立两个普通数组
     
116.         int[] a = new int[2];
     
117.         int[] b = new int[2];
     
118. 
     
119.         // 给数组个元素赋值
     
120.         for (int i = 0; i < a.length; i++) {
     
121.             a[i] = i;
     
122.             b[i] = i + 1;
     
123.         }
     
124. 
     
125.         System.out.println('\n' + "基本类型数组交换前：a[0] = " + a[0] + ", a[1] = " + a[1]);
     
126.         System.out.println("基本类型数组交换前：b[0] = " + b[0] + ", b[1] = " + b[1]);
     
127. 
     
128.         // 交换两个基本类型数组
     
129.         Person.swapIntArray(a, b);
     
130.         System.out.println('\n' + "基本类型数组交换后：a[0] = " + a[0] + ", a[1] = " + a[1]);
     
131.         System.out.println("基本类型数组交换后：b[0] = " + b[0] + ", b[1] = " + b[1]);
     
132.         
     
133.         // 改变对象数组的内容
     
134.         Person.changeObjectArray(arraya, arrayb);
     
135.         System.out.println('\n' + "对象数组内容交换并改变后：arraya[1] = " + arraya[1].toString());
     
136.         System.out.println("对象数组内容交换并改变后：arrayb[1] = " + arrayb[1].toString());
     
137.         
     
138.         // 改变基本类型数组的内容
     
139.         Person.changeIntArray(a, b);
     
140.         System.out.println('\n' + "基本类型数组内容交换并改变后：a[1] = " + a[1]);
     
141.         System.out.println("基本类型数组内容交换并改变后：b[1] = " + b[1]);
     
142.     }
     
143. }

复制代码

程序运行结果如下：



结论：不管是对象、基本类型还是对象数组、基本类型数组，在函数中都不能改变其实际地址但能改变其中的内容。

好像很厉害。不过现在看起来感觉好深奥

传值,只有传值

这个比指针好点..

6666666666666666666

楼主在类里面写的方法无效.

好，说得不错

1379号监听员 发表于 2015-11-5 22:38
在函数中交换：引用数据类型形参指向的地址改变了，而实际参数并没有改变；基本数据类型形参的值改变了，跟 ...

格式出了点错，将就着看吧，我自己总结的东西，大神请指教

在函数中交换：引用数据类型形参指向的地址改变了，而实际参数并没有改变；基本数据类型形参的值改变了，跟实际参数也没什么关系。
所以在函数中经过形参这么一搅合，交换等于啥也没干。
在函数中改变属性值：引用数据类型把地址赋给形参，形参根据地址改变属性的值，所以最终实参的属性发生变化；基本数据类型，因为是把数值赋给了形参，改变的只是形参的值，跟实参毛关系没有。
所以在函数中改变属性，基本数据类型不改变，引用数据类型改变。
写了一段代码作为补充：

1. class Car {
   
2. 
   
3. private String color;
   
4. private int num;
   
5. Car(){}
   
6. Car(String color,int num){
   
7. this.color = color;
   
8. this.num = num;
   
9. }
   
10. public void run(){
    
11. System.out.println(color+"的有"+num+"个轮子的小车跑起来了");
    
12. }
    
13. public static void swap(Car c1,Car c2) {
    
14. Car c3 = c1;
    
15. c1 = c2;
    
16. c2 = c3;
    
17. }
    
18. 
    
19. }
    
20. class Demo_CarTest {
    
21. public static void main(String[] args) {
    
22. Car c1 = new Car("红色",4);
    
23. Car c2 = new Car("黄色",3);
    
24. System.out.println("交换前");
    
25. c1.run();
    
26. c2.run();
    
27. Car c3 = c1;
    
28. c1 = c2;
    
29. c2 = c3;
    
30. System.out.println("交换后");
    
31. c1.run();
    
32. c2.run();
    
33. /*
    
34. System.out.println("调用函数交换后");
    
35. Car.swap(c1,c2);
    
36. c1.run();
    
37. c2.run();
    
38. */
    
39. }
    
40. }

复制代码

上边代码表示的是如果不在函数中作交换，引用型数据类型的地址是改变的。

学习了，日哥果然牛叉

其实我一直都是懂的