代码如下：
class Test
{
        public static void swap(A x, A y)//互换操作
        {
                A temp = x;
                x = y;
                y =temp;
        }
        public static void main(String[] args)
        {
                A m = new A(6);
            A n = new A(10);
                /*
                m = n;
                m.run();
                输出结果为10
                */

                /*
                A p = m;
                p.run();
                输出结果为6
                */
                swap(m,n);
                m.run(); //输出结果为6，引用内容未互换
}

class A
{
        private int a;
        A(int a)
        {
                this.a = a;
        }
        void run()
        {
                System.out.println(a);
        }
}

首先这里传入的参数都是引用类型，你把m的地址值传给了x,n的地址值传给了y,然后在方法中，只是把x,和y所指向的内容换了，而m,n指向的内容并没有换啊。

volvoxc 发表于 2014-3-12 20:19
首先这里传入的参数都是引用类型，你把m的地址值传给了x,n的地址值传给了y,然后在方法中，只是把x,和y所指 ...

{:3_60:}为什么c语言里可以

下面是我的理解，若有不对，请多多指出。

榨菜 发表于 2014-3-12 20:29
下面是我的理解，若有不对，请多多指出。

:o幸苦了

焚雨成灰 发表于 2014-3-12 20:22
为什么c语言里可以

C语言里面传的应该是地址    swap（ inx *x,int *y）

1.你的swap是有用的，你的m,n是一个引用型变量，它交换的是地址值。代码可以看出x.y有变化（那是哈希值，不是地址值，但确实变了）
2.你应该想
   public static void swap(A x, A y)//互换操作
        {
                        System.out.println("x.."+x );
                        System.out.println("y..."+y );
                A temp = x;
                x = y;
                y =temp;
                        System.out.println("x..."+x );
                        System.out.println("y..."+y );
        }

x..A@2f0f94a0
y...A@27e6ac83
x...A@27e6ac83
y...A@2f0f94a0

2.你应该想交换是是6和10，你可以变一下，代码懂了很多，
class Test
{
        public static void swap(int x, int y)//互换操作 1.更改
        {
                int temp = x;
                x = y;
                y =temp;
                                System.out.println("m =6..."+x+"   "+"n=10..."+y);
        }
        public static void main(String[] args)
        {
                A m = new A(6);
                          A n = new A(10);
                /*
                m = n;
                m.run();
                输出结果为10
                */

                /*
                A p = m;
                p.run();
                输出结果为6
                */
                                //2.更改
                                int x= m.a;
                                int y = n.a;
                swap(x,y);
               // m.run(); //输出结果为6，引用内容未互换
                }
}

class A
{//更改
          int a;
        A(int a)
        {
                this.a = a;
        }
        void run()
        {
                System.out.println(a);
        }
}

代码动了很多，写错

主要是进入方法后，x,y参数指向了m,n对象的位置，之后再改变只是改变x，y的指向，而不涉及m，n

volvoxc 发表于 2014-3-12 20:19
首先这里传入的参数都是引用类型，你把m的地址值传给了x,n的地址值传给了y,然后在方法中，只是把x,和y所指 ...

正解！！

主要是进入方法后，x,y参数指向了m,n对象的位置，之后再改变只是改变x，y的指向，而不涉及m，n

请和用函数改变对应地址种a的值区分开。

焚雨成灰 发表于 2014-3-12 20:22
为什么c语言里可以

c语言中是用到了指针，指针指向的是同一块内存空间，所以指针指向的内容改变了，那么原本的数据就改变了，但是java中swap(A x, A y)，x和y都是引用，也就是x和y里面存放的是实参传递过来实体的地址，进行互换操作之后，x和y指向了互换后的实体，但是外面实参所指向的实体并没有改变，所以没有达到互换效果。如果想要达到c语言里的效果，可以在swap(A x, A y)里面把实体里的数据互换即可。
改变效果如下：

1. 
   
2. public static void swap(A x, A y)//互换操作
   
3.         {        /*
   
4.                 A temp = x;
   
5.                 x = y;
   
6.                 y =temp;
   
7.                 */
   
8.                 int temp = x.a;//要完成此操作需把类A的属性a改成非私有的
   
9.                 x.a = y.a;        //或者在类A中设置一个getA()方法
   
10.                 y.a = temp;
    
11.         }
    

复制代码

java 语言是严谨的，你调用swap（）方法互换引用变量的值，只在swap（）方法中有效，而在main方法中无效。因为你调用swap（）方法根本就没有把结果返回来。相当于白干。因此，当我们对一个数据进行修改后，并用修改后的数据进行运算，一定要有返回值。

1. class Test
   
2. {               
   
3.                     
   
4.          public static A swap(A x, A y)//互换操作
   
5.         {
   
6.                  A temp = x;
   
7.                  x = y;
   
8.                  y =temp;
   
9.                      return x;
   
10.          }
    
11.          public static void  main(String[] args)
    
12.          {            
    
13.                    A m = new A(6);
    
14.                A n = new A(10);
    
15.                A x=swap(m,n);
    
16.                     x.run(); //输出结果为10
    
17.            }
    
18. }
    
19. 
    
20. class A
    
21. {
    
22.          private int a;
    
23.          A(int a)
    
24.          {
    
25.                  this.a = a;
    
26.          }
    
27.          void run()
    
28.          {
    
29.                  System.out.println(a);
    
30.          }
    
31. }

复制代码