前面其实也看到过许多关于参数传递的问题,知道一点值传递的东西,比如:按我的理解,在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
到底还是没有理解他底层是怎么弄的,还期待高手来解释一下,到底这个参数在底层是怎么传来传去的
但是可能我的理解不够深入,所以今天遇到的问题还是来问一下: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
到底还是没有理解他底层是怎么弄的,还期待高手来解释一下,到底这个参数在底层是怎么传来传去的
在上面的例子中
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.
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());
}}
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.
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