1. public class JavaApp {
   
2.         public static void main(String[] args) throws Exception
   
3.     {
   
4.                     Yinyong ya=new Yinyong("Zhangsan");
   
5.                     Yinyong yb=new Yinyong("Lisi");
   
6.                     swap(ya,yb);//众所周知，类是引用类型，为什么这个函数无效？
   
7.                     System.out.println("a="+ya.name+" b="+yb.name);
   
8.                     Change(ya);//而这个函数却有效？
   
9.                     System.out.println(ya.name);
   
10.     }
    
11.        
    
12.         public static void swap(Yinyong y1,Yinyong y2)
    
13.         {
    
14.                 Yinyong temp=y1;
    
15.                 y1=y2;
    
16.                 y2=temp;
    
17.         }
    
18.        
    
19.         public static void Change(Yinyong y)
    
20.         {
    
21.                 y.name="Wangwu";
    
22.         }
    
23.        
    
24. }
    
25. 
    
26. class Yinyong
    
27. {
    
28.         String name;
    
29.         Yinyong(String name)
    
30.         {
    
31.                 this.name=name;
    
32.         }
    
33. }
    

复制代码

public class JavaApp {
        public static void main(String[] args) throws Exception
    {
                    Yinyong ya=new Yinyong("Zhangsan");
                    Yinyong yb=new Yinyong("Lisi");
                    swap(ya,yb);//众所周知，类是引用类型，为什么这个函数无效？//参数调用是值调用而不是引用调用，这里是把ya和yb的值传给了
                                                                       //swap的形参，但是ya和yb并没有改变。                    System.out.println("a="+ya.name+" b="+yb.name);
                    Change(ya);//而这个函数却有效？//因为这个函数改变了对象的属性，是对象的属性值变了，但是ya并没有改变                    System.out.println(ya.name);
    }
        
        public static void swap(Yinyong y1,Yinyong y2)
        {
                Yinyong temp=y1;
                y1=y2;
                y2=temp;
        }
        
        public static void Change(Yinyong y)
        {
                y.name="Wangwu";
        }
        
}

class Yinyong
{
        String name;
        Yinyong(String name)
        {
                this.name=name;
        }
}

java里是传值。

1. package com.itcast.test;
   
2. 
   
3. public class JavaApp {
   
4. 
   
5. /**
   
6. * @param args
   
7. */
   
8. public static void main(String[] args) {
   
9. // TODO Auto-generated method stub
   
10. Yinyong ya=new Yinyong("Zhangsan");
    
11. 
    
12. Yinyong yb=new Yinyong("Lisi");
    
13. 
    
14. swap(ya,yb);//众所周知，类是引用类型，为什么这个函数无效？
    
15. 
    
16. System.out.println("a="+ya.name+" b="+yb.name);
    
17. 
    
18. Change(ya);//而这个函数却有效？
    
19. 
    
20. System.out.println(ya.name);
    
21. 
    
22. }
    
23. 
    
24. 
    
25. 
    
26. public static void swap(Yinyong y1,Yinyong y2) //将ya,yb的值传给了局部变量y1,y2，结果只是y1,y2交换了值，这两个变量在函数生命期结束时结束。
    
27. 
    
28. {
    
29. 
    
30. Yinyong temp=y1;
    
31. 
    
32. y1=y2;
    
33. 
    
34. y2=temp;
    
35. 
    
36. }
    
37. 
    
38. 
    
39. 
    
40. public static void Change(Yinyong y)
    
41. 
    
42. {
    
43. 
    
44. y.name="Wangwu";
    
45. 
    
46. }
    
47. }
    
48. 
    
49. 
    
50. 
    
51. class Yinyong
    
52. 
    
53. {
    
54. 
    
55. String name;
    
56. 
    
57. Yinyong(String name)
    
58. 
    
59. {
    
60. 
    
61. this.name=name;
    
62. System.out.println(this.name);
    
63. 
    
64. }
    
65. 
    
66. }
    
67. 
    
68. 
    

复制代码

修改一下：

1. package com.itcast.test;
   
2. 
   
3. public class JavaApp {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.         Yinyong ya=new Yinyong("Zhangsan");
    
11. 
    
12.         Yinyong yb=new Yinyong("Lisi");
    
13. 
    
14.         //swap(ya,yb);//众所周知，类是引用类型，为什么这个函数无效？
    
15.         
    
16.         Yinyong temp = ya;
    
17.         ya = yb;
    
18.         yb = temp;
    
19.         System.out.println("a="+ya.name+" b="+yb.name);
    
20. 
    
21.         Change(ya);//而这个函数却有效？
    
22. 
    
23.         System.out.println(ya.name);
    
24. 
    
25.     }
    
26. 
    
27.         
    
28. 
    
29.     /*public static void swap(Yinyong y1,Yinyong y2) //将ya,yb的值传给了局部变量y1,y2，结果只是y1,y2交换了值，这两个变量在函数生命期结束时结束。
    
30. 
    
31.     {
    
32. 
    
33.             Yinyong temp=y1;
    
34. 
    
35.             y1=y2;
    
36. 
    
37.             y2=temp;
    
38. 
    
39.     }
    
40.     */
    
41. 
    
42.    
    
43. 
    
44.     public static void Change(Yinyong y)
    
45. 
    
46.     {
    
47. 
    
48.             y.name="Wangwu";
    
49. 
    
50.     }
    
51. }
    
52. 
    
53. 
    
54. 
    
55. class Yinyong
    
56. 
    
57. {
    
58. 
    
59.         String name;
    
60. 
    
61.         Yinyong(String name)
    
62. 
    
63.         {
    
64. 
    
65.                 this.name=name;
    
66.                 System.out.println(this.name);
    
67. 
    
68.         }
    
69. 
    
70. }
    
71. 
    

复制代码

这个问题是对象指针局部改变而实际对象指针没变的问题。
在swap()，你的操作是将ya指向了存放Lisi的对象，而yb指向了存放Zhangsan的对象。这个操作是成功的！
但当这个函数swap()结束时，上述操作由于是在函数内进行，在函数外是没有改变的。也就是在内存中开辟了两个指针进行操作，结束时释放了。

而下一个函数change()成功是因为它操作的是yb指针所指向对象的内容，改变的是实际内容，程序结束时，内容已经改变。

swap()函数建议修改：
public static void swap(Yinyong y1,Yinyong y2)
        {
                String temp=y1.name;
                y1.name=y2.name;
                y2.name=temp;
        }

       因为Java里方法参数的传递实际上只有值传递（不管基本类型或引用类型），对基本类型来说是把其值传递了一份过去，而对引用类型来说实际是把引用地址的值复制一份传递了过去。
      另外，只有用new方法创建的对象的实际成员数据是存放在堆里面的，而其他方法内部定义的变量都存放在栈中，一旦出了方法的范围就失效，会被内存回收。
       知道了以上两点，就可以分析了，swap方法里y1,y2,temp都是存放在栈里的只保存引用类型地址的变量，不管他们怎么交换，实际上不会改变堆里面的内容，而main方法里的ya, yb的引用类型虽然其地址仍在栈中，而实际数据在堆中，程序中没有任何改变其内容的语句，因此，不会产生交换。