java中数组对象的引用

[dufangwen060105]

这是代码，问题在下面。

/*这是我在网上找这个问题时遇到的代码*/
 class Person {

    private String name;//姓名

    private String sex;//性别

    public Person(String x, String y) {
        this.name = x;
        this.sex = y;
    }

    public void setStatus(String x, String y) {
        this.name = x;
        this.sex = y;

    }

    public String toString() {

        return name + sex;

    }

    //  －－－－－交换普通对象－－－－－
    public static void changeref(Person tmpx, Person tmpy) {
        //交换tmpx和tmpy对象
        Person swapref = tmpx;
		tmpx = tmpy;
        tmpy = swapref;
        System.out.println("在方法中交换的结果: refa =" + tmpx.toString());
        System.out.println("在方法中交换的结果: refb =" + tmpy.toString());
		System.out.println();
    }

    // －－－－－ 交换数组对象－－－－－
    public static void changeArrayRef(Person[] x, Person[] y) {

        //交换数组对象
		//System.out.println(x);
		//System.out.println(x[1]);
        Person  swaparrayref = x[1];
		System.out.println(swaparrayref);
        x[1] =y[1];
        y[1] = swaparrayref;

    }
    

    //－－－－－交换数组－－－－－
    public static void changeArray(int[] x,int[] y) {
 
       int[] tmp =x;       
       x = y; 
       y = tmp;    
    }  
}

public class Demo {

    public static void main(String[] args) {
        
        //－－－－－－－建立并构造两个对象－－－－－－－－－
        Person refa = new Person("张三", "男");
        Person refb = new Person("李四", "男");

        //交换refa对象和refb对象
        Person.changeref(refa, refb);
        //从交换结果中看出，实际对象并未交换
        System.out.println("在主函数中交换的结果 refa = " + refa.toString());
        System.out.println("在主函数中交换的结果 refb = " + refb.toString());
                
        //－－－－－－－建立两个对象数组－－－－－－－－－－
        Person[] arraya = new Person[2];
        Person[] arrayb = new Person[2];
        
        //分别构造数组对象
        arraya[0] = new Person("王五","男");
		arraya[1] = new Person("wo","男");
        arrayb[0] = new Person("赵六","男");
		arrayb[1] = new Person("ni ","女");
         
        /*数组对象为null时，不能设置其值，必须先构造它（即调用构造函数），再用其它方法设置其值
      */
     
        System.out.println('\n'+"数组对象交换前的结果 arraya = " + arraya[1].toString());
        System.out.println("数组对象交换前的结果 arrayb = " + arrayb[1].toString());
        //交换这两个数组对象
        Person.changeArrayRef(arraya, arrayb);
        System.out.println("－交换后的结果 arraya = " + arraya[1].toString());
        System.out.println("－交换后的结果 arrayb = " + arrayb[1].toString());

        //－－－－－－－建立两个普通数组－－－－－－－－－
        int[] a = new int[2];
        int[] b = new int[2];
   
        //给数组个元素赋值
        for(int i =0;i<a.length;i++){
            a[i] = i;
            b[i] = i+1;
        }    
        
        System.out.println('\n'+"数组交换前 inta[0] = " + a[0]);
        System.out.println("数组交换前 intb[0] = " + b[0]);
        
        //交换数组
        Person.changeArray(a,b);        
  
        System.out.println("－交换后的结果 inta[0] = " + a[0]);
        System.out.println("－交换后的结果 intb[0] = " + b[0]);   
    }
}

得到的结果：
---------- java运行 ----------
在方法中交换的结果: refa =李四男
在方法中交换的结果: refb =张三男

在主函数中交换的结果 refa = 张三男
在主函数中交换的结果 refb = 李四男

数组对象交换前的结果 arraya = wo男
数组对象交换前的结果 arrayb = ni 女
wo男
－交换后的结果 arraya = ni 女
－交换后的结果 arrayb = wo男

数组交换前 inta[0] = 0
数组交换前 intb[0] = 1
－交换后的结果 inta[0] = 0
－交换后的结果 intb[0] = 1

输出完毕 (耗时 2 秒) - 正常终止


我的问题简而言之就是java中方法调用时，如果是对象为实参的话，应该是传址是吧，但是在下面的程序里面，我有了疑问：交换普通对象我能理解，应该是将实参（即对象的引用）“拷贝”给了形参，在第一个方法里面，形参发生了交换，但是实参是没有变化的，因为二者是独立的。但是在第二个方法执行后，实参也发生了改变，这个我就不理解了，希望大家帮忙解决。

[ruisheng_412]

这个题目，我还有些疑问，为什么person数组里的值，可以交换，但是int数组的值不可以交换？

[dz007]

[Quote=引用 13 楼 ruisheng_412 的回复:]
这个题目，我还有些疑问，为什么person数组里的值，可以交换，但是int数组的值不可以交换？
[/Quote]

这例子里面只有int数组交换，没有数组的值交换

你自己写一个值交换，是可以交换的

[勇哥聊IT]

地球上的两个坐标是不可以改变的，改变的只是寄存在这上面的东西

[ruisheng_412]

[Quote=引用 14 楼 dz007 的回复:]
引用 13 楼 ruisheng_412 的回复:
这个题目，我还有些疑问，为什么person数组里的值，可以交换，但是int数组的值不可以交换？


这例子里面只有int数组交换，没有数组的值交换

你自己写一个值交换，是可以交换的
[/Quote]


// －－－－－ 交换数组对象－－－－－
public static void changeArrayRef(Person[] x, Person[] y) {

//交换数组对象
//System.out.println(x);
//System.out.println(x[1]);
Person swaparrayref = x[1];
System.out.println(swaparrayref);
x[1] =y[1];
y[1] = swaparrayref;

}
这个不是person［］ 数组吗

[24K純帥]

说的这么晕乎，是不是数组也交换的地址呀

[dz007]

好长啊…………

所有的传递都是传对象的地址

[haojia0716]

在java里没有引用传递 只有值传递 这个值指的是实参的地址的拷贝
得到这个拷贝地址后 你可以通过它修改这个地址的内容 因为此时拷贝地址和原地址是同一地址


但是你不能改变原地址 也就是说就算你改变了拷贝地址 原地址是不会变的

[awusoft]

Object o = new Object();//一个引用变量o,引用这时候创建的对象

Object b = o;//另 一个引用变量,让它也引用刚才创建的对象.

这时候通过b改变那个对象,和通过o去改变是一样的.改变的同一个对象.


银行原来是没有银行卡的,只有存折,你可以使用存折去取钱,后来......升级了,引入了银行卡,这时候你可以为你的帐户去开一个银行卡.那个存折和银行卡都是指向同一个帐户,存折取钱,银行卡再去查,钱就少了.反过来一样.


我可以让b重新引用其它的对象.

b = new Object();//这时候b不再引用前面创建的对象,改变引用.

相当于银行卡与另一个帐户挂勾了,与原来的那个不相干.

这里是引用了存折与银行卡.你可以想像一下,一个帐户两个存折......

希望你能明白

[pluminsnow]

[Quote=引用 3 楼 awusoft 的回复:]
Object o = new Object();//一个引用变量o,引用这时候创建的对象

Object b = o;//另 一个引用变量,让它也引用刚才创建的对象.

这时候通过b改变那个对象,和通过o去改变是一样的.改变的同一个对象.


银行原来是没有银行卡的,只有存折,你可以使用存折去取钱,后来......升级了,引入了银行卡,这时候你可以为你的帐户去开一个银行卡.那个存折和银行卡都是指向同一个帐户,存折取钱,银行卡再去查,钱就少了.反过来一样.


我可以让b重新引用其它的对象.

b = new Object();//这时候b不再引用前面创建的对象,改变引用.

相当于银行卡与另一个帐户挂勾了,与原来的那个不相干.

这里是引用了存折与银行卡.你可以想像一下,一个帐户两个存折......

希望你能明白

[/Quote]

生动形象

[dz007]

看完楼主的例子，我也晕了……………………

[dz007]

可能int[]是内容值传递，而不是int[]引用传递

只能这么解释了……

[lixkyx]

[Quote=引用 17 楼 leehomwong 的回复:]
说的这么晕乎，是不是数组也交换的地址呀
[/Quote]

一点也没有错。如果函数参数是数组类型的，则交换的是数组的起始地址，换句话说，实参数组和形参数组是同一个东东；如果函数参数是数组的元素，而数组元素的类型是基本数据类型，例如，则实参变量和形参变量是两个互不相干的变量。

如果函数参数是对象类型，则交换的也是对象的引用（地址），也就是说实参对象和形参对象是同一个对象；如果函数参数是基本数据类型，则交换的是数值，即实参变量和形参变量是两个互不相干的变量。
。

[jayqean]

呵呵```看了楼主的贴,我的解释如下:
对楼主所说的对于那个对象数组的交换弄不清，我有如下的解释:
Person.changeArrayRef(arraya, arrayb);将对象数组地首地址arraya,arrayb作为实参传递 （打个比方：arraya的地址为12ff71,arrayb的地址为12ff72）
交换对象数组的时候 changeArrayRef(Person[] x, Person[] y) 实质上是在堆栈里开辟了一个空间，名字为x ,y.(正如LZ开始说的:是arraya,arrayb相应的一个副本一样的意思) x里存放的实质上是形参arraya传过来的地址 12ff71,同理,y里放的是12ff72.
接下来看所写的方法,所作的功能是通过地址将对象数组里的值逐个进行交换，故arraya所指的堆区里的值和arrayb所指的堆区里放的值交换了``因为他们指向同一块区域

[jayqean]

个别人想不通最后那个交换数组的话：
传的是数组的首地址跟楼主说的传对象的引用是一个意思，可以看楼主相应的解释

[bigbro001]

记号先，慢慢看。。。

[tianshu2000]

建议楼主看一下关于内存分配的分析。对于引用类型变量和形参变量的介绍很详细哈

[薄荷]

建议看看Java 的内存分析，很C语言的不一样。每一个内存仔细分析了就明白了。

[breezes2008]

一切都是传值调用。---请勿必理解这句话。

[dz007]

假设有
int a=0
然后
a=1
首先a得到0的地址100，再接着a得到1的地址200，基本变量都是在内存中新建的，而不是LZ想的把100地址的值变为1

[dufangwen060105]

[Quote=引用 20 楼 jayqean 的回复:]
呵呵```看了楼主的贴,我的解释如下:
  对楼主所说的对于那个对象数组的交换弄不清，我有如下的解释:
    Person.changeArrayRef(arraya, arrayb);将对象数组地首地址arraya,arrayb作为实参传递  （打个比方：arraya的地址为12ff71,arrayb的地址为12ff72）
    交换对象数组的时候 changeArrayRef(Person[] x, Person[] y)  实质上是在堆栈里开辟了一个空间，名字为x ,y.(正如LZ开始说的:是arraya,arrayb相应的一个副本一样的意思)  x里存放的实质上是形参arraya传过来的地址 12ff71,同理,y里放的是12ff72.
    接下来看所写的方法,所作的功能是通过地址将对象数组里的值逐个进行交换，故arraya所指的堆区里的值和arrayb所指的堆区里放的值交换了``因为他们指向同一块区域
   
[/Quote]
这个我还不是很理解，处理对象数组的方法，里面的内容为什么可以交换而处理对象的方法不可以？我觉得在处理对象的那个方法中，发生交换的是两个形参引用，而处理对象数组的方法也是如此啊 ？可是为什么处理对象的就不可以啊？