黑马程序员技术交流社区

标题: 关于类的引用 [打印本页]
作者: 邓超军    时间: 2012-7-17 11:49
标题: 关于类的引用
  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. }

  26. class Yinyong
  27. {
  28.         String name;
  29.         Yinyong(String name)
  30.         {
  31.                 this.name=name;
  32.         }
  33. }
复制代码
作者: 李伟    时间: 2012-7-17 11:59
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;
        }
}
作者: 黑马刘涛    时间: 2012-7-17 12:00
本帖最后由 黑马刘涛 于 2012-7-17 12:07 编辑

java里是传值。
  1. package com.itcast.test;

  3. public class JavaApp {

  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  10. Yinyong ya=new Yinyong("Zhangsan");

  12. Yinyong yb=new Yinyong("Lisi");

  14. swap(ya,yb);//众所周知，类是引用类型，为什么这个函数无效？

  16. System.out.println("a="+ya.name+" b="+yb.name);

  18. Change(ya);//而这个函数却有效？

  20. System.out.println(ya.name);

  22. }



  26. public static void swap(Yinyong y1,Yinyong y2) //将ya,yb的值传给了局部变量y1,y2，结果只是y1,y2交换了值，这两个变量在函数生命期结束时结束。

  28. {

  30. Yinyong temp=y1;

  32. y1=y2;

  34. y2=temp;

  36. }



  40. public static void Change(Yinyong y)

  42. {

  44. y.name="Wangwu";

  46. }
  47. }



  51. class Yinyong

  53. {

  55. String name;

  57. Yinyong(String name)

  59. {

  61. this.name=name;
  62. System.out.println(this.name);

  64. }

  66. }


复制代码
修改一下：
  1. package com.itcast.test;

  3. public class JavaApp {

  5.         /**
  6.          * @param args
  7.          */
  8.         public static void main(String[] args) {
  9.                 // TODO Auto-generated method stub
  10.         Yinyong ya=new Yinyong("Zhangsan");

  12.         Yinyong yb=new Yinyong("Lisi");

  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);

  21.         Change(ya);//而这个函数却有效？

  23.         System.out.println(ya.name);

  25.     }

  27.         

  29.     /*public static void swap(Yinyong y1,Yinyong y2) //将ya,yb的值传给了局部变量y1,y2，结果只是y1,y2交换了值，这两个变量在函数生命期结束时结束。

  31.     {

  33.             Yinyong temp=y1;

  35.             y1=y2;

  37.             y2=temp;

  39.     }
  40.     */

  42.    

  44.     public static void Change(Yinyong y)

  46.     {

  48.             y.name="Wangwu";

  50.     }
  51. }



  55. class Yinyong

  57. {

  59.         String name;

  61.         Yinyong(String name)

  63.         {

  65.                 this.name=name;
  66.                 System.out.println(this.name);

  68.         }

  70. }

复制代码
作者: 樊佰轩    时间: 2012-7-17 12:05
这个问题是对象指针局部改变而实际对象指针没变的问题。
在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;
        }
作者: 陆鹏    时间: 2012-7-17 12:10
       因为Java里方法参数的传递实际上只有值传递（不管基本类型或引用类型），对基本类型来说是把其值传递了一份过去，而对引用类型来说实际是把引用地址的值复制一份传递了过去。
      另外，只有用new方法创建的对象的实际成员数据是存放在堆里面的，而其他方法内部定义的变量都存放在栈中，一旦出了方法的范围就失效，会被内存回收。
       知道了以上两点，就可以分析了，swap方法里y1,y2,temp都是存放在栈里的只保存引用类型地址的变量，不管他们怎么交换，实际上不会改变堆里面的内容，而main方法里的ya, yb的引用类型虽然其地址仍在栈中，而实际数据在堆中，程序中没有任何改变其内容的语句，因此，不会产生交换。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2