WHY?这样的结果

public class test{
public static void main(String sgf[]) {
        StringBuffer a = new StringBuffer("A");
        StringBuffer b = new StringBuffer("B");
        operate(a, b);
        System.out.println(a + "," + b);
    }

    static void operate(StringBuffer x, StringBuffer y) {
        x.append(y);// 在此x经append(y)之后就变成了AB
        y = x;// 为啥y没有改变呢？
    }
}

结果:AB,B

评论

5 楼 java2times 2008-10-20  

传值---传递基本数据类型参数
传引用---传递对象

4 楼 java2times 2008-09-02  

如果在方法中把对象（或数组）作为参数，方法调用时，参数传递的是对象的引用（地址）;

传值---传递基本数据类型参数

3 楼 java2times 2008-09-02  

public class Inc{
public static void main(String argv[]){
                Inc inc = new Inc();
                int i =0;
                inc.fermin(i);
                i = i++;
                System.out.println(i);
        }
        void fermin(int i){
                i++;
        }
}
睁大眼睛看仔细
结果是0   !!

对基本类型是传值，pass a copy

2 楼 java2times 2008-09-02  

public   class   test   ...{
      int   a   =   3;
      public   void   plus(int   b)...{
        b     =   b+1;
        }
        public   static   void   main(String   args[])
      ...{
        test   t   =   new   test();
        t.plus(t.a);
        System.out.println(t.a);
      }
      }
传值就相当于你把你的文件拷贝到另一个地方,你对你所拷贝的文件(和源文件有一模一样的信息)做什么都不会影响源文件
传引用就相当于你把该文件创建个快捷方式(差不多),你打开了,修改了,也就修改了
public   class   test   ...{
      int   a   =   3;
      public void add()...{
          a=a+1;
      }
     
      public   void   plus(test   b)...{
       b.add();
        }
        public   static   void   main(String   args[])
      ...{
        test   t   =   new   test();
        t.plus(t);
        System.out.println(t.a);
      }
}
下面我要阐述一下为什么你的代码是3而我的代码是4，JAVA存储变量有两种形式：
（1）一种是基础类型（int,long）类型以及自定义类型不用new关键字的（User   u;）
（2）另一种是用New的（User   U=new   User();）
这两种方式有很大的不同，第一种方式存储对象在JVM   pool里面，第二种方式存储在JVM   Heap里面，你错就错在对JVM   pool的运行机理不了解，pool中的数据一旦创建无法人为删除，只能通过gc定期删除，所以int   i=5;   i=6;新创建6，i指向新的6，但是5依然存在，只不过没有引用指向它了，等待gc将其回收。

楼主吧t.a传给了t.plus();传的是我说的第一类对象，因为在t里面，a=3;定义的，在plus里面，形势参数被指向4（因为3+1）并不是覆盖3的位置，而是新创建一个空间存4，此时形势参数t指向4，外面的实际变量t还指向3相当于函数里外各有一个t分别指向3，4；虽然是把3的地址传进函数去了，但是地址的内容被复制了，所以看起来与传值方式效果相同，JAVA这点好：虽然只保留一种传值方式，还能用这种方式的巧妙变化模拟出另一种方式的效果。

至于我那个例子，就是采用第二种方式，我传的对象在heap里，对heap里的数据更改，就是覆盖原有的位置而不复制，那么自然结果就是4。

在JAVA里根本没有传值这个概念，所有的东西都是引用（内存地址），但是可以通过JAVA特有的复制替代原理用引用模拟实现与传值相同的效果。
JAVA的参数传递也就不存在什么引用传递了（因为JAVA根本不支持引用），一切都是值传递。

关于简单类型，很好理解，就是拷贝一个值给被调方法。
这个值一旦拷贝完毕，就和原来的变量脱离一切关系。
所以，如论参数在方法内如何被改变，方法外的变量是永远不变的，因为它们是两个完全无关的变量。

关于对象（即类的实例），传值方式和简单类型精确一致。
但不同的是，被赋予一个对象的变量本身并不包含这个对象，而只是包含该对象的地址。
所以，传值的时候，会把变量的拷贝（即对象地址的拷贝）传给被调方法；这样做的结果是，两个变量指向同一个对象。
在方法内部，虽然你不能改变方法外的那个变量，但因为参数获得了那个变量所指的对象的地址，所以，它可以操作原来变量所指的那个对象。

可以把对象比作电视机，对象引用比作遥控器。
现在我需要让屋子里的另一个人也可以和我一样操作电视机，我会给他一个和我手上一模一样的遥控器，但不是给他一台新的电视机。
于是，两个人都可以同时操作同一台电视机了，这就是地址传递。

但是，如果他把遥控器拿到另一间屋子去操作另一台电视机了，我手上的遥控器不会受丝毫影响，因为，我只是给他一个拷贝，我自己的还是自己的。
所以，这既是地址传递又是值传递。
“地址”是指对象的地址，“值”是指地址的值。这就是JAVA的参数传递。

1 楼 java2times 2008-09-02  

java中的值传递和引用传递
值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 数的值。
引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。
下面举例说明：
传值---传递基本数据类型参数
public    class           PassValue{
    static void exchange(int a, int b){//静态方法，交换a,b的值
        int temp;
        temp = a;
        a = b;
        b = temp;
    }
    public static void main(String[] args){
       int i = 10;
       int j = 100;
       System.out.println("before call: " + "i=" + i + "\t" + "j = " + j);//调用前
        exchange(i, j);                                                                    //值传递，main方法只能调用静态方法
        System.out.println("after call: " + "i=" + i + "\t" + "j = " + j);//调用后
    }
}
运行结果：
        before call: i = 10        j = 100
        after    call: i = 10        j = 100
说明：调用exchange(i, j)时，实际参数i，j分别把值传递给相应的形式参数a，b,在执行方法exchange()时，形式参数a，b的值的改变不影响实际参数i和j的值，i和j的值在调用前后并没改变。
引用传递---对象作为参数
如果在方法中把对象（或数组）作为参数，方法调用时，参数传递的是对象的引用（地址），即在方法调用时，实际参数把对对象的引用（地址）传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象（数组），方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。
class Book{
    String name;
    private folat price;
    Book(String n,    float ){                //构造方法
        name = n;
        price = p;
    }
    static  void  change(Book a_book,    String n,    float p){    //静态方法，对象作为参数
            a_book.name = n;
            a_book.price = p;
    }
    public void output(){        //实例方法，输出对象信息
        System.out.println("name: " + name + "\t" + "price: " + price);
    }
}
public class PassAddr{
    public static void main(String [] args){
        Book b = new Book("java2",    32.5f);
        System.out.print("before call:\t");        //调用前
        b.output();
        b.change(b,    "c++",    45.5f);            //引用传递，传递对象b的引用，修改对象b的值
        System.out.print("after call:\t");            //调用后
        b.output();
    }
}
运行结果：
        before    call:    name:java2        price:32.5
        after       call:    name:c++          price:45.5
说明：调用change(b,"c++",45.5f)时，对象b作为实际参数，把引用传递给相应的形式参数a_book,实际上a_book也指向同一个对象，即该对象有两个引用名：b和a_book。在执行方法change()时，对形式参数a_book操作就是对实际参数b的操作。