public class MyClass {
static void aMethod(StringBuffer sf1, StringBuffer sf2) {
sf1.append(sf2); sf2 = sf1;
}
public static void main(String[] args){
StringBuffer sf1 = new StringBuffer("A");
StringBuffer sf2 = new StringBuffer("B");
aMethod(sf1,sf2);
System.out .println(sf1+ "":"+sf2);
} }
为什么输出结果是：AB:B
我感觉应该是 AB：AB

这样改写后sf1输出结果是AB，这是局部变量与成员变量的区别

1. public class MyClass {
   
2. static void aMethod(StringBuffer sf1, StringBuffer sf2) {
   
3.         sf1.append(sf2);
   
4.         sf2 = sf1;
   
5.         System.out.println(sf1);
   
6.         System.out.println(sf2);
   
7. }
   
8.         public static void main(String[] args){
   
9.         StringBuffer sf1 = new StringBuffer("A");
   
10.         StringBuffer sf2 = new StringBuffer("B");
    
11.          aMethod(sf1,sf2);
    
12.         System.out .println(sf1+ ":"+sf2);
    
13.         }
    
14. }

复制代码

不是说局部变量和成员变量  
这个是这么回事  str1.append（str2）方法是将两个字符串连接之后返回给str1这个字符创，所以     sf1.append(sf2);  这个方法调用之后    sf1="AB";   单sf2还是原来的值  
所以结果是AB:B

aMethod(sf1,sf2);  传递参数的时候是传递引用，把main函数里的实际参数sf1,sf2引用的地址，复制给aMethod()方法里的形式参数sf1,sf2。
sf1.append(sf2); 操作了形式参数sf1引用的对象，操作完后对象的值变成了AB.此时main函数里实参sf1的引用也指向这个对象，所以输出的值是"AB"
sf2 = sf1; 操作了形式参数sf2引用的指向，使它指向sf1引用的对象。而此时main函数里的实参sf2的引用没有改变，还是指向原来的对象。值为"B".

赵利斌 发表于 2013-5-12 21:23
不是说局部变量和成员变量  
这个是这么回事  str1.append（str2）方法是将两个字符串连接之后返回给str1这 ...

这个问题还真是局部变量和成员变量的关系。结合上楼的代码

1. 
   
2. public class MyClass {
   
3. static void aMethod(StringBuffer sf1, StringBuffer sf2) {
   
4.         sf1.append(sf2);
   
5.         sf2 = sf1;
   
6.         System.out.println(sf1);
   
7.         System.out.println(sf2);
   
8. }
   
9.         public static void main(String[] args){
   
10.         StringBuffer sf1 = new StringBuffer("A");
    
11.         StringBuffer sf2 = new StringBuffer("B");
    
12.          aMethod(sf1,sf2);
    
13.         System.out .println(sf1+ ":"+sf2);
    
14.         }
    
15. }

复制代码

可以看出 在方法内的sf1和sf2都变成了AB，但是为什么主函数里sf2还是原来的值呢？产生这个问题的原因是因为append(),该方法的api文档说此方法会在 this（目标）对象上实现同步，就是说执行方法aMethod内部的sf1.append(sf2);形参变化的同时，实参sf1也同步变成了AB。所以产生上面效果。

这个与局部变量成员变量关系不大，4楼说的对，这个应该是实参与形参的问题
实参是实体参数，即main中的sf1和sf2
形参是函数中传入的参数，它只是对实参的一个引用，形参在函数中发生修改，作用于函数，而不会影响到实参，这aMethod中的sf1和sf2即是形参
所以看到，形参sf2在函数中变化后，没有影响到实参sf2
而实参sf1发生了改变，是因为sf1调用append方法的原因，这个方法操作的是形参引用的对象，也就是实参sf1
所以，最终看到的结果就是：AB:B

4L好给力啊   嗯。楼主你看下这个就比较清楚了

1. 
   
2. public class MyClass
   
3. {
   
4.       static void aMethod(StringBuffer a1, StringBuffer b2)
   
5.    {
   
6.             a1.append(b2);
   
7.             b2 = a1;
   
8.     }
   
9.     public static void main(String[] args)
   
10.    {
    
11.          StringBuffer sf1 = new StringBuffer("A");
    
12.          StringBuffer sf2 = new StringBuffer("B");
    
13.          aMethod(sf1,sf2);
    
14.          System.out .println(sf1+ "":"+sf2);
    
15.    }
    
16. }
    

复制代码

主要形参的名称和实参的名称相同太迷惑了，换成a1 b2就清楚多了。
一：append改变了sf1指向的字符串，所以实参sf1指定的字符串改变了，故输出AB；
二：而在aMethod 方法中 b2=a1 只是把形参a1记录的地址赋给了b2。这并没有改变实参sf2所指向的字符串。（虽然形参a1 b2一开始和实参sf1 sf2记录的地址一样）