麻烦给分析一下这道题

stringjavse

解决方案 »

  1.   

    运行结果： sb1sb2,sb2麻烦运行一下，对结果分析分析，
      

  2.   

    运行了，结果：sb2
    sb1sb2,sb2
      

  3.   

    分析一下结果  为什么是  sb1sb2,sb2
      

  4.   

    分析一下结果  为什么是  sb1sb2,sb2
    a = b;这一行有没有不会影响main方法中的sb1,sb2；
    你先看一下StringBuffer，a.append(b)没有生成新的对象，是在原对象的基础上进行操作的；
      

  5.   

    sb1和a指向同一地址（假设为&A），sb2和b指向同一地址（假设为&B），在myfunction内改变了地址&A的内容后，又把a指向了地址&B，所以在myfunction内输出的的实际为地址&B的内容，sb1和sb2所指的地址没变，但地址&A的内容被改变了。
      

  6.   


    对这个  分析分析，，，代码中不是a=b，为什么只是局部起作用。。，而那个 a.append(b)起作用了
      

  7.   

    考察对象引用，方法传参问题
    这里要想到C里面的指针Java方法传参，如果是对象的话，传的是对象的引用，什么是对象的引用？我的理解有点类似于C的指针
    简单说一下Java中，对象和基本变量在内存中的存储8大基本对象一般存在堆区，存的是变量的实际值
    对象，引用有一块专门的区域存储，我记得是栈，这里不敢乱说，但可以肯定的是不是堆区有了以上两点基础知识，我们来分析一下这道题在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型
      

  8.   

    变量，赋值                  如果不是基本数据类型(int float char..)     
    那么变量  的值，就是个引用。
    引用，怎么产生，只要不是基本数据类型，就会自动产生引用。还是习惯习惯，看书看书，
      

  9.   

    public A 是A类的构造函数，你每次new A() 的时候都会调用构造函数，即调用public A()，构造函数里面你定义了2个StringBuffer，然后做了一个连接字符串的操作，最终得到你的结果。这里面楼主主要得知道对象的引用，这里面定义了两个对象，四个引用，sb1，a引用指向对象值“sb1”；sb2，b引用指向对象值“sb2”，当执行myfunction（）方法时，将sb2的值追加到了sb1的值上，所以这时候的sb1，a引用指向对象值就是“sb1sb2”；sb2，b引用指向对象值仍然是“sb2”，当执行到a = b 时，把引用a指向了对象值为“sb2”的对象，所以打印a.toString()结果应该是“sb2”，但是sb1和sb2 引用的指向一直都没变，所以结果楼主所示。
      

  10.   


    在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型好的 解释很清楚，明白了，
      
    但是有一点，，
    堆区存放的是new出来的对象和类中方法的名，
    代码区存放的是  类中方法的具体代码，
    栈区存放的是  对象引用和基本数据类型，
    数据区，存放的是 数据常量和String类型的字符串记得是这样的
      

  11.   

    我总感觉在java中说  堆 说 栈  都是蒙人的。
    能把堆和栈说清的，应该是JVM那的层次的吧。
    反正我只知道引用这说法。
      

  12.   


    在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型还有就是  public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 答案就是这样：sb2
    sb1,sb2
      

  13.   

    jvm  一个指向一个存值。
      

  14.   


    上面有两段代码，一个是用的是  stringbuffered的 append方法实现的，另一个是通过string的+实现的，，怎么结果不一样，麻烦分析一下
      

  15.   


    在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型好的 解释很清楚，明白了，
      
    但是有一点，，
    堆区存放的是new出来的对象和类中方法的名，
    代码区存放的是  类中方法的具体代码，
    栈区存放的是  对象引用和基本数据类型，
    数据区，存放的是 数据常量和String类型的字符串记得是这样的涨知识了，一直以为基本对象是放在堆里
    需要好好看看编译原理来～～～谢谢指正～
      

  16.   


    在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型还有就是  public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 答案就是这样：sb2
    sb1,sb2
    答案应该是这样啊，我的意思是可能你以为你的代码答案应该是这样
      

  17.   


    在构造函数里，创建了两个对象
    sb1和sb2，请注意，这里是对象
    myfunction是A对象的方法，参数是两个对象，因此当构造函数调用的时候，传的是这两个对象引用的副本
    相当于C指针的副本，指针是个什么东西？指针是地址啊，它存的是对象实际内容的地址呀myfunction是对a（实际操作的是sb1的内容）追加b
    然后又让a指向b（a =b）(这里请把Java对象的引用当成指针来看待，但不能完全当成，这里是不会有内存泄漏的问题)
    前边说过，传的是引用的副本,也就是说sb1和a都是指向"sb1"，然后通过方法把"sb1"变成了“sb1sb2”,这个方法再把a指向"sb2"
    因此sb1这个对象内容变了，a的指向变了
    于是有了这个结果修改把代码改成
    public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 我猜你以为的答案会是这样
    sb2
    sb1,sb2这里需要说明一下，虽然String不是基本类型
    但在Java里可以当成基本类型来用，有基本类型的一些性质，也是存在堆区，但它不是基本类型还有就是  public class A { 
        
        /** Creates a new instance of Test */ 
        public A() { 
    //        StringBuffer sb1 = new StringBuffer("sb1"); 
    //        StringBuffer sb2 = new StringBuffer("sb2"); 
         String sb1 = "sb1";
         String sb2 = "sb2";
           myfunction(sb1,sb2); 
           System.out.println(sb1+","+sb2);
       } 
    //   public void myfunction(StringBuffer a,StringBuffer b){ 
    //        a.append(b); 
    //        a = b;
    //        System.out.println(a.toString());
    //    } 
       public void myfunction(String a,String b){ 
       a = a + b ; 
       a = b;
       System.out.println(a.toString());
       } 
        public static void main(String[] args) { 
            new A(); 
        } 
    } 答案就是这样：sb2
    sb1,sb2
    答案应该是这样啊，我的意思是可能你以为你的代码答案应该是这样很透彻的解释，接分
      

  18.   

    撸主要搞明白，引用是值传递的，所以a = b 丝毫不会改变sb1，但是a.append(b)却改变了sb1，好好想想吧