1.         public static void swap(Integer x, Integer y) {
   
2.                          
   
3.                           }
   
4. 
   
5.                     public static void swap(int x, int y) {
   
6.                      
   
7.                     }
   
8. 
   
9.                     public static void main(String[] args) {
   
10.                         int x = 1;
    
11.                         int y = 2;
    
12.                         swap(x, y);
    
13.                         System.out.print("x=" + x);
    
14.                         System.out.print("y=" + y);
    
15.                         Integer a = new Integer(1);
    
16.                         Integer b = new Integer(2);
    
17.                         swap(a, b);
    
18.                         System.out.print("a=" + a.intValue());
    
19.                         System.out.print("b=" + b.intValue());
    
20. 
    
21.                  }

复制代码

实现两个数交换！

x=1y=2a=1b=2

public static viod swap(int x,int y){
     int temp;
     temp = x;
     x = y;
     y = temp;
}

这个办不到，Java对普通类型的变量是不支持引用传递的，都是值传递，C中的普通类型的传递有一个特殊方法是作为指针来传递，但java中不存在指针，所以实现不了。
Integer是数据包装类，a和b都是引用，这么说应该是按引用传递的，但实际验证却发现，这个说法也是错误的。

网上有这么两个例子：
public class Test {
    public static void test(StringBuffer str) {
        str.append(", World!");
    }
    public static void main(String[] args) {
        StringBuffer string = new StringBuffer("Hello");
        test(string);
        System.out.println(string);
    }
}　　运行结果：

　　Hello, World!
　　test(string) 调用了 test(StringBuffer) 方法，并将 string 作为参数传递了进去。这里 string 是一个引用，这一点是勿庸置疑的。引用是一种数据类型，而且不是对象，所以它不可能按引用传递，所以它是按值传递的，它么它的值究竟是什么呢？是对象的地址。

　　由此可见，对象作为参数的时候是按值传递的，对吗？错！为什么错，让我们看另一个例子：

/* 例 4 */
/**
* @(#) Test.java
* @author fancy
*/
public class Test {
    public static void test(String str) {
        str = "World";
    }
    public static void main(String[] args) {
        String string = "Hello";
        test(string);
        System.out.println(string);
    }
}　　运行结果：

Hello
为什么会这样呢？因为参数 str 是一个引用，而且它与 string 是不同的引用，虽然它们都是同一个对象的引用。str = "World" 则改变了 str 的值，使之指向了另一个对象，然而 str 指向的对象改变了，但它并没有对 "Hello" 造成任何影响，而且由于 string 和 str 是不同的引用，str 的改变也没有对 string 造成任何影响，结果就如例中所示。

　　其结果是推翻了参数按值传递的说法。那么，对象作为参数的时候是按引用传递的了？也错！因为第二个例子的确能够说明它是按值传递的。

　　结果，就像光到底是波还是粒子的问题一样，Java 方法的参数是按什么传递的问题，其答案就只能是：即是按值传递也是按引用传递，只是参照物不同，结果也就不同。


给个连接，其中下篇讲了在java中的数据置换：
http://www.bccn.net/Article/kfyy/java/jszl/200601/3069.html

、楼上的回答
输出后的结果是交换了么？
    希望回帖的时候不要理所当然

我有个小方法可以交换，可以把方法的参数换成数组
因为数组是java中唯一保留了指针的地方

要想将两个地址对应的值交换，就只能用指针了，哈哈

fighting 发表于 2013-3-28 12:51
我有个小方法可以交换，可以把方法的参数换成数组
因为数组是java中唯一保留了指针的地方

确切说，java中到处都是指针，只不过不叫指针了，改为叫引用了。如果想了解更多，请看：http://bbs.itheima.com/forum.php ... =%E6%8C%87%E9%92%88

黄玉昆 发表于 2013-3-28 13:21
确切说，java中到处都是指针，只不过不叫指针了，改为叫引用了。如果想了解更多，请看：http://bbs.ithei ...

是这样的，但是从数组来看，我们现在只能说它是指针了，而其它的对象已经成为引用了

1. public class Demo1 {
   
2.     public static void swap(Integer x, Integer y) {
   
3.         
   
4.     }
   
5. 
   
6.         public static void swap(int x, int y) {
   
7.                 /*
   
8.                  * 在此方法中将传递进来的两个数据转换了
   
9.                  * 二此方法中的变量x,y已经不是main()中的变量x,y了：因为变量的作用范围在{}之间有效
   
10.                  */
    
11.                 int temp =x;
    
12.                 x = y;
    
13.                 y = temp;
    
14.                 System.out.println("x="+x+",y="+y);//输出交换后的值
    
15.        
    
16.         }
    
17.        
    
18.         public static void main(String[] args) {
    
19.           int x = 1;
    
20.           int y = 2;
    
21.           swap(x, y);//无返回值
    
22.           System.out.print("x=" + x);//输出的是main()中的x值
    
23.           System.out.print("y=" + y);//输出的是main()中的y值
    
24.           Integer a = new Integer(1);
    
25.           Integer b = new Integer(2);
    
26.           swap(a, b);
    
27.           System.out.print("a=" + a.intValue());
    
28.           System.out.print("b=" + b.intValue());
    
29.        
    
30.         }
    
31. }

复制代码

在主函数中运行swap（）方法后，由于方法是void类型，不会返回任何值；
swap（x,y）只是把x,y的具体数值传递给函数，而函数中定义的变量x,y已经不是主函数中的变量x,y了。
所以不能把交换后的数据传给main()中的变量x,y了。

意思是结论下来   除了数组方式  就是置换不了吗？

这题我刚刚做。。。。。。。。。。。。。。反射做~~~

Java是传递引用的拷贝~~~反射可破~

1. public static void swap(Integer x, Integer y) {
   
2.                
   
3.                 Class classX = x.getClass();
   
4.                
   
5.                 int c = x;
   
6.                
   
7.                 try {
   
8.                         
   
9.                         Field field1 =  classX.getDeclaredField("value");
   
10.                         field1.setAccessible(true);
    
11.                         field1.set(x,y);
    
12.                         
    
13.                         Field field2 =  classX.getDeclaredField("value");
    
14.                         field2.setAccessible(true);
    
15.                         field2.set(y,c);
    
16.                         
    
17.                 } catch (Exception e) {
    
18.                         e.printStackTrace();
    
19.                 }
    
20.                
    
21.         }

复制代码

详情见这个帖子 5 楼~~
http://bbs.itheima.com/thread-43240-1-1.html