前面其实也看到过许多关于参数传递的问题,知道一点值传递的东西,比如:按我的理解,在java中参数传递一直是值传递,但是可以将一般的对象传进方法后只可以改变其属性值,但是不能改变该引用所指向的那个整个对象的;
但是可能我的理解不够深入,所以今天遇到的问题还是来问一下:class A{
private int x;
public A(){

}
public A(int x){
this.x=x;
}
public void setX(int x){
this.x=x;
}
public int getX(){
return x;
}
}class B{
private A a;
public void setA(A a){
this.a=a;
}

public void printA(){
System.out.println("A is "+a.getX());
}
}public class Args_test { static void setA(A a){
a=new A(5);
}
public static void main(String[] args) {
A a=new A();
a.setX(1);
B b=new B();
b.setA(a);//
a.setX(2);//
b.printA();//就是这三句,a作为一个值传进去了,已经成为b的一部分,然后a自己改变其属性,
//居然会改变b中的A对象的属性?这怎么看起来就像c的指针引用之类的啊
setA(a);//
System.out.println("then the A is "+a.getX());
                //这两句才是真的值传递嘛,连新建一个对象它都不改变
}}
结果是
A is 2
then the A is 2
到底还是没有理解他底层是怎么弄的,还期待高手来解释一下,到底这个参数在底层是怎么传来传去的

解决方案 »

  1.   

    值传递和引用传递是从两个不同得角度来看的。很多人理解为值传递是因为大家把引用也看作值的一种,这样看来Java全部是值传递。事实上我们认为基本数据类型是采用值传递方式,而对象类型参数采用引用传递方式进行的。
    在上面的例子中
    b.setA(a)//是把对象a的引用传递给了b,即b拥有了访问对象a具体内容的钥匙而已,a中的内容改变了在b在访问的时候当然会体现出来。
    另外你那个static 方法 
    static void setA(A a){
            a=new A(5);
        }
    完全没有用,你把引用传进去了,但是在用new 关键字的时候已经把它指向的内存地址改变了,但是它是一个局部变量,最后一句打印语句
    System.out.println("then the A is "+a.getX());
                    //这两句才是真的值传递嘛,连新建一个对象它都不改变

    访问的是成员实例a而不是局部变量a.
      

  2.   

    class A{
        private int x;
        public A(){
            
        }
        public A(int x){
            this.x=x;
        }
        public void setX(int x){
            this.x=x;
        }
        public int getX(){
            return x;
        }
    }class B{
        private A a;
        public void setA(A a){   //把A引用传进去了,结果就是this.a跟a指向了同一地址,所以只要这地址的内容改变了,
                             //它们两个指向的内容也就改变,而且它们所指向的内容是相同的
            this.a=a;
        }
        
        public void printA(){
            System.out.println("A is "+a.getX());
        }
    }public class Args_test {    static void setA(A a){
            a=new A(5);
        }
        public static void main(String[] args) {
            A a=new A();
            a.setX(1);
            B b=new B();
            b.setA(a);//
            a.setX(2);//a引用跟b.a引用指向同一块地方,
                     //你用a改变这地方的内容,b.a也指向你改变的地方,所以b.a指向的内容也变拉
            b.printA();//
            setA(a);//
            System.out.println("then the A is "+a.getX());
                     
        }}
      

  3.   

    首先,B把a引用(地址)作为自己的成员,a中的成员x变了但a引用(地址)并没有变化!所以B得成员的地址还是a引用啊
      

  4.   

    ArrayList a = new ArrayList();
    ArrayList b = a;对象只有一个,就是第一个new的时候产生的,有两个引用,a与b.不管通过a还是b操作,都是操作同一个对象
    方法调用时,在外边把对象创建好,然后把引用传过去~~~~~,让调用的方法里边也是访问这个对象.为什么叫引用????
    ArrayList a  =new ArrayList();
    在new ArrayList的时候,内存中开辟了空间存在这个对象.然后把这个段空间的首地址(也叫对象的引用)返回.
    所以a只是一个变量,就是一个变量!它里边存在的是一种地址,这个值是某段内在空间的首地址!Object o = new Object();
    这里的o也就 是一个变量!它的值是一某段空间的首地址.
    a,b,o的值是内存地址~~所以把它都叫做引用变量!因为通过它就可以访问到具体的对象.
    首先要为a分配内存,因为它要存值.这个值是地址值,然后还要为new 后边的分配内存,把这段内存的首地址返回.
    int i=10;
    要给i分配地方,但它的值就是10.
      

  5.   

    java中对于对象来说是引用传递
      

  6.   

    如1楼说言,具体点:
    main方法最先执行
    ……
    A a=new A();
    为了方便说明,我们称这个a为a1,此时定义了一引用a1,a1具体指向一个A对象new A()a.setX(1);
    这个a还是a1,a1指向的new A()中的x被设定成 1 了B b=new B();
    定义了一个叫b的引用,b指向一个具体的B对象new B(),new B()中private A a会被执行,此时生成一个指向A对象的引用a,我们称为a2,此时a2不执向某个具体的A对象b.setA(a(这是a1));
    此时由于this.a(a2) = a(a1)被执行,即a2指向a1指向的那个new A()了a(这是a1).setX(2);//此时上面new A()中的x被修改成了2
    b.printA();
    执行System.out.println("A is "+a.getX())这里的a是a2,但a2和a1指向同一个new A(),这个new A()中的x值是2setA(a(a1));
    此时将传递一个a1的拷贝,称为a3,a3也指向a1所指向的new A(),然后a(这就是那个a3)=new A(5);,此时a3不再指向a1指向的new A(),而a1仍指向new A(),并且语句结束时a3和new A(5)被销毁,即语句结束后不再有a3这引用和new A(5)这个对象System.out.println("then the A is "+a(还是a1).getX());
    a1还是指向自己指向的new A(),当中的x值还是2