1. public class test {
   
2.         public static void main(String[] args) {
   
3.                 Cat cata = new Cat("a",13);
   
4.                 Cat catb = new Cat("b",5);
   
5.                 System.out.println("cata的名字为"+cata.getName());
   
6.                 System.out.println("catb的名字为"+catb.getName());
   
7.                 swap(cata,catb);
   
8.                 System.out.println("cata的名字为"+cata.getName());
   
9.                 System.out.println("catb的名字为"+catb.getName());
   
10.         }
    
11.         public static void swap(Cat a,Cat b) {
    
12.             Cat temp = a;
    
13.             a = b;
    
14.             b = temp;
    
15.         }
    
16. 
    
17. }

复制代码

定义一个cat类
以下是参数对调的方法

1. public class Cat {
   
2.         public Cat(String name,int age) {
   
3.                 this.name = name;
   
4.                 this.age = age;
   
5.         }
   
6.         private String name;
   
7.         private int age;
   
8.         public String getName() {
   
9.                 return name;
   
10.         }
    
11.         public void setName(String name) {
    
12.                 this.name = name;
    
13.         }
    
14.         public int getAge() {
    
15.                 return age;
    
16.         }
    
17.         public void setAge(int age) {
    
18.                 this.age = age;
    
19.         }
    
20. }
    

复制代码

为什么结果是一样的
cata的名字为a
catb的名字为b
cata的名字为a
catb的名字为b

两段顺序粘反了。。。
大家凑合看吧

结果：
cata的名字为a
catb的名字为b
cata的名字为a
catb的名字为b
结果没错的
  public static void swap(Cat a,Cat b) {

            Cat temp = a;

            a = b;

            b = temp;
}
这里交换的是对象，不是属性，属性属于对象，new Cat 每个cat都有自己的name ,age.  就像你和张三换位置，但张三的名字，年龄还是他的，你的还是你的

1. public class TestPlus {
   
2.     public static void main(String[] args) {
   
3.             Cat01 cata = new Cat01("a",13);
   
4.             Cat01 catb = new Cat01("b",5);
   
5.             
   
6.             System.out.println("cata的名字为:"+cata.getName()+",cata的年龄为:"+cata.getAge());
   
7.             System.out.println("catb的名字为:"+catb.getName()+",catb的年龄为:"+catb.getAge());
   
8.             
   
9.             swap(cata,catb);
   
10.             System.out.println("交换后结果如下：");
    
11.             
    
12.             System.out.println("cata的名字为:"+cata.getName()+",cata的年龄为:"+cata.getAge());
    
13.             System.out.println("catb的名字为:"+catb.getName()+",catb的年龄为:"+catb.getAge());
    
14.     }
    
15.    
    
16.     public static void swap(Cat01 a,Cat01 b) {
    
17.             //前面的同学说过了，不能直接交换对象。
    
18.         String nameA = a.getName();
    
19.         String nameB = b.getName();
    
20.         
    
21.         a.setName(nameB);
    
22.         b.setName(nameA);
    
23.         
    
24.         int ageA = a.getAge();
    
25.         int ageB = b.getAge();
    
26.         
    
27.         a.setAge(ageB);
    
28.         b.setAge(ageA);
    
29.     }
    
30. }
    
31. 
    
32. class Cat01 {
    
33.     private String name;
    
34.     private int age;
    
35.    
    
36.     public Cat01(String name,int age) {
    
37.             this.name = name;
    
38.             this.age = age;
    
39.     }
    
40. 
    
41.     public String getName() {
    
42.             return name;
    
43.     }
    
44.    
    
45.     public void setName(String name) {
    
46.             this.name = name;
    
47.     }
    
48.    
    
49.     public int getAge() {
    
50.             return age;
    
51.     }
    
52.    
    
53.     public void setAge(int age) {
    
54.             this.age = age;
    
55.     }
    
56. }
    

复制代码

沈文杰 发表于 2013-3-13 16:24

我的意思是为什么两个对象的地址没有交换
值的话只是为了看着方便而已
正常来说经过swap方法
两个对象的地址应该对调了啊
但是结果确显示没有任何变化

黑马17期-闫东东 发表于 2013-3-13 15:49
结果：
cata的名字为a
catb的名字为b

我的意思是为什么两个对象的地址没有交换
值的话只是为了看着方便而已
正常来说经过swap方法
两个对象的地址应该对调了啊
但是结果确显示没有任何变化

实在看不出来的话可以画一个内存图，这样就知道怎么回事了，下面是我画的内存图，我把值传递用3这个数字表示

HM李帅 发表于 2013-3-13 16:52
我的意思是为什么两个对象的地址没有交换
值的话只是为了看着方便而已
正常来说经过swap方法

看下图把，应该可以看懂的

你将属性封装在对象中，如果你能在不调用对象中的方法的情况下进行改变，那封装的意义何在？

cata和catb存储的内存地址值，调用swap方法只是将cata和catb的值传递给方法区中的a和b，然后交换 a 和 b 的值，实际上栈内存中的cata 和catb 的值并没有改变。

这样交换没有什么意义，但如果将地址传递给 a 和 b ，再通过a、b获取对象，进而改变对象的内容，实际上也就是改变cata、catb所指向的对象的内容