为什么输出是Hello？而不是Hello World？

Question

public class Test {   
    public static StringBuffer doSomething(StringBuffer buff) {   
        buff = new StringBuffer();   
        buff.append("Hello World");   
        return buff;   
    }   
  
    public static void main(String[] args) {   
        StringBuffer buff = new StringBuffer();   
        buff.append("Hello");   
        doSomething(buff);   
        System.out.println(buff);   
    }   
}  

Answer 1

 buff = new StringBuffer();    执行了以后，不再指向原来那个对象，而是一个新的对象可以这样  
doSomething(buff);    改成 buff =  doSomething(buff);    

Answer 2

或者是把   buff = new StringBuffer();  这行删除

Answer 3

public class Test {    
    public static StringBuffer doSomething(StringBuffer buff) {    
         //2 看这里你又重新生成了一个StringBuffer.
        buff = new StringBuffer();    
     
        buff.append("Hello World");    
        return buff;    
    }    
   
    public static void main(String[] args) {    
        StringBuffer buff = new StringBuffer();    
        buff.append("Hello"); 
         // 1,你着里传的是 buff对象   
        doSomething(buff); 
         // 你输出的事实上是main中的 buff 所以是 Hello   
        System.out.println(buff);    
    }    
}   修改一下你就可以输出Hello World 了 public static void main(String[] args) {    
        StringBuffer buff = new StringBuffer();    
        buff.append("Hello"); 
        buff= doSomething(buff); 
        //这时你就可以输出Hello World 了。
        System.out.println(buff);    
    }  

Answer 4

楼上正确你调用上面那个静态函数，返回的字符串根本就没用变量接收，下面打印buff还是主函数里面的。。你用buff= doSomething(buff);  就可以打印出最经典的Hello World

Answer 5

楼主是想看方法传递参数，调方法改变buff的值吧。你传过去的是buff的引用的一个复制，在doSomething(buff)里 ，你重新new了个并且把内容改为hello world,但是这对主方法里的内容改不了了，因为你新new了个对象，主方法里的buff对象里还是hello。你return的buff，主方法没人收，不要被同名的buff迷惑

Answer 6

public class Test {    
    public static StringBuffer doSomething(StringBuffer buff) {    
        buff = new StringBuffer();  //buff重新指向另一个对象,  
        buff.append("Hello World");  //对其进行修改!  
        return buff;    //返回这个新对象!
    }    
   
    public static void main(String[] args) {    
        StringBuffer buff = new StringBuffer();    
        buff.append("Hello");  //这里  buff.toString()为"hello"
        doSomething(buff);    这里copy一个buff的引用传给doSomething()的引数buff1,
        //上面方法回来之后buff还是指向原来的地址,而不是在方法内部重新指向的那对象
        System.out.println(buff);    //所以内容没改变
    }    
}   

Answer 7

public class test6 {

public static StringBuffer doSomething(StringBuffer buff) {    
        buff = new StringBuffer();    
        buff.append("Hello World");    
        return buff;    
    }    
   
    public static void main(String[] args) {    
        StringBuffer buff = new StringBuffer();    
        buff.append("Hello");    
        //doSomething(buff);    
        System.out.println(doSomething(buff));    
    }    }
这样才可以输出你想要的“Hello World”，

Answer 8

你的程序虽然是正确的，只是你的doSomething这个方法的返回值你没有接收，
所以你输出的还是main方法里面的那个StringBuffer的实列，要输出＂Hello Word＂的话，
你只要用StringBuffer buff１ ＝doSomething(buff)在输出System.out.println(buff1)就行了

Answer 9

我还是去先看看书籍咯，对象 NEW 后面应该是新创建的实例，你在main里面 又搞了一个肯定是调用不了 那个static里的buff了不知道我这样说，可以吗？本人是个菜鸟！

Answer 10

LZ的问题是在于，虽然在函数doSomething内部改变了参数所引用的对象，但是，函数调用时候的传入的参数和函数内部的参数是两个指向相同实例的引用。实际上就是......栈上变量（这个变量是个“指针”）的值传递到函数里。你改变被复制过来的栈变量，主函数里的栈变量又不会改变引用。

Answer 11

注意2,(StringBuffer buff)里的buff引用不同于main方法的buff引用，先是main方法的buff引用赋值给doSomething方法的buff引用，使doSomething方法的buff和main方法的buff指向同一对象,但他们是两个引用，在内存中有独立的空间

Answer 12

Test函数内的buff,不再是指向主函数main里的buff,所以，你的TESt函数对主函数main根本没影响。

Answer 13

public class HelloJava {
public static StringBuffer doSomething(StringBuffer buff) {
//这个buff实际上就是一个局部变量,
//在调用doSomething(bf);的时候就相当于先做了buff = bf;这个操作
buff = new StringBuffer();//这里又将buff重新赋值,这时buff和bf无任何关系
buff.append("Hello World");
return buff;
} public static void main(String[] args) {
StringBuffer bf = new StringBuffer();
bf.append("Hello");
doSomething(bf);
System.out.println(bf);
}
}

Answer 14

java里面的参数传递全是值传递。所以会出现这种情况

Answer 15

Hello World并没有加到打印的buff中去 

Answer 16

要这样写
buff =  doSomething(buff);

Answer 17

因为在那个方法里重新new了个对象，他所作的操作发生在那个对象上。返回式新对象就失效了。所以是hello.

Answer 18

java传参是值传递，别的就啥也不跟你说了，自己好好想想吧。

Answer 19

buff =doSomething(buff);  就能打出来了
否则就把buff 定义成全局的  

Answer 20

public class Test {    
    public static StringBuffer doSomething(StringBuffer buff) {  
//传过StringBuffer以后 你又new 了一个新的对象
       // buff = new StringBuffer();    
        buff.append("Hello World");    
        return buff;    
    }    
   
    public static void main(String[] args) {    
        StringBuffer buff = new StringBuffer();    
        buff.append("Hello"); 
System.out.println(buff);  //结果 Hello
//doSomething 返回的是 StringBuffer 你没有把返回值 打印 呢
        buff = doSomething(buff);    
        System.out.println(buff); //这样结果就是  HelloHello World 了啊，是两次的追加了
    }     
}   

Answer 21

可是参考类型的参数传递不是传址吗，在调用DOSOMETHING的时候不是改变了BUFF指向的对象了么

Answer 22

buff 的引用不会改变，改变的只是那个方法的形参而已

Answer 23

补补你java基础吧。。水平啊 

Answer 24

你在doSomething这个方法里面重新创建了一个对象并把方法体内的buff引用指向了新创建的那个对象！
所以doSomething这个方法实际上并没有改变原来那个对象的值

Answer 25

main方法中的doSomething(buff);    
没有做任何改变buff的工作，所以有与没有一个样。

Answer 26

很明显  buf的值还是dosomething函数返回的值

Answer 27

main()方法中的buff是一个局部变量
而上边的那个方法中的是令外一个局部变量··

Answer 28

你往dosomething里传递的只是对象引用的复制啊~

Answer 29

就凭我的直觉都知道肯定是hello了。。^_^

Answer 30

public class Test {   
    public static StringBuffer doSomething(StringBuffer buff) {   
        buff.append("Hello World");   
        return buff;   
    }   
  
    public static void main(String[] args) {   
        StringBuffer buff = new StringBuffer();   
        buff.append("Hello");   
        doSomething(buff);   
        System.out.println(buff);   
    }   
}   
或者
public class Test {   
    public static StringBuffer doSomething(StringBuffer buff) {   
        buff = new StringBuffer();   
        buff.append("Hello World");   
        return buff;   
    }   
  
    public static void main(String[] args) {   
        StringBuffer buff = new StringBuffer();   
        buff.append("Hello");   
        buff = doSomething(buff);   
        System.out.println(buff);   
    }   
}   

Answer 31

你在调用了那个方法后需要重新赋值给buff才能得到新的值

Answer 32

 以我的想法就是，分析内存，从main()开始，首先是程序加载到code segment 中，
   首先为static 变量创建对象和分配内存空间，如图 Data segment 主要是存放 静态变量和字符串和常量,
创建了一个StringBuffer buff分配在栈内存中 就是我给出的图片中的 stack 区, 然后 new StringBuffer();对象，在堆内存中，如图 heap 区.   buff调用append方法传 "Hello"进来 ， doSomething(buff);//调用doSomething 方法传一个StringBuffer 类型 参数为buff 进入 doSomething方法体，new 一新 StringBuffer对象并且调用 append方法，值为 "Hello World"，return buff；反大括号，局部变量消失，也就是说 doSomething 方法体内的 buff对象消失.
最后print  main 方法中的 buff对象的值。=======
 个人观点，不对的地方还得请大家指出来。