1：通过使用异或运算，可以快速将两个数的值交换：原理如下：
    我们知道异或是相同取0相反取1，如：0101异或1101的结果是1000。如对两个数，经过三次进行异或运行后的结果是这两个数的值互换。如 a =       0101, b=1101,则进行的操作如下：
           第一次异或运算： a = a ^b = 1000
           第二次异或运算： b = a^b = 0101
           第三次异或运算： a = a^b = 1101
至此，a和b这两个数的值已经互换了，并且没有使用到额外的储存空间。
那么，能不能直接写一个函数直接将a和b作为值参数进行数值互换呢。答案是否定的。我们知道函数参数的以值传递方式是对参数的值拷贝到当前函数栈帧中，相当于对传递过来的参数作一个内存拷贝吧。这样，传递过来的参数值改变并没有影响到原来与参数的变量或常量的值。如果是传递过来的是引用，结果就不一样了。
使用java语言简单实现如下：

public static void quickSwap(int vaules[]){
    values[0] = values[0]^values[1];
    values[1] = values[0]^values[1];
    values[0] = values[0]^values[1];
 }


2：还可以将你要交换的参数作为对象的一个变量来交换，例如：

class ABC{
 int abc;
 }
 public class ChangeObject {
 public static void main(String args[]){
 ABC a1=new ABC();
 ABC a2=new ABC();
 a1.abc=111;
 a2.abc=222;
 System.out.println("a.abc:"+a1.abc+" b.abc:"+a2.abc);
 change(a1,a2);
 System.out.println("a.abc:"+a1.abc+" b.abc:"+a2.abc);
 }
 public static void change(ABC a,ABC b){
 ABC temp=new ABC();
 temp.abc=a.abc;
 a.abc=b.abc;
 b.abc=temp.abc;
 }
 }


3：在程序中实现交换两个数的功能并不复杂，但如果不使用中间变量，就需要动一下脑筋。在本文介绍了两个方法（其实原理都是一个）。其基本原理就是数的中和。 也就是说，通过某种运算（二元运算）将a和b两个数变成一个数，并保存在其中一个变量中。然后再通过同样的运算符将a或b中和掉。这样实际上是利用了a或 b本身作为了中间变量。
    先看第一个算法。

static class Num
 {
     int a;
     int b;
 }
 public static void swap1(Num num)
 {
     num.a = num.a + num.b;
     num.b = num.a - num.b;
     num.a = num.a - num.b;
 }



上面代码通过“+”运算符将a和b的运算结果赋给了a（这时a是中间变量）。然后再计算b，这时a的值已经是（a+b）了，因此，a再减b就是原来的a。 而这时b已经是原来的a了，因此，再用运算后的a（实际上是a+b）减运算后的b（实际上是原来的a），就是原来的b了，最后将这个b赋值给a。
    实际上，我们还可以使用“*”、“/”等符号来实现同样的效果，代码如下：

public static void swap2(Num num)
 {
     num.a = num.a * num.b;
     num.b = num.a / num.b;
     num.a = num.a / num.b;
 }
 public static void swap3(Num num)
 {
     num.a = num.a - num.b;
     num.b = num.a + num.b;
     num.a = num.b - num.a;
 }


    上面代码在Java中没有什么问题（但使用“/”时，分母和分子不能为0）。就算溢出也会得到正确的结果，但有某些语言中（如C语言），可能会抛出溢出错误，不了避免这种错误。可以加判断，代码如下：

public static void swap4(Num num)
 {
     // 不同符号
     if (num.a * num.b <= 0)
     {
         num.a = num.a + num.b;
         num.b = num.a - num.b;
         num.a = num.a - num.b;
     }
     else
     {
         num.a = num.a - num.b;
         num.b = num.a + num.b;
         num.a = num.b - num.a;
     }
 }


    当然，我们还有更好的方法，就是使用异或运算符，我们知道，任何数与0异或后仍然为它本身，两个相同的数异或后为0。根本这种特性，可以有如下代码。

public static void swap5(Num num)
 {
     num.a = num.a ^ num.b;
     num.b = num.a ^ num.b;
     num.a = num.a ^ num.b;
 }


Java函数在传递过程中只能够传值，不能传址。这样，函数的参数在函数内部做任何变化就都不会反映到外部调用者来。所以解决之道就是要找到要交换对象的引用。对于普通的值类型，像int或者double这样的可以改传他们的包装类Integer和Double。而对于本来就是引用类型的对象，则需要对他们再包一层。一个好的方法就是将参数列表改成数组

import java.io.*;
 public class Compare
 {
 public static void change(int[] a) throws Exception
 {
 int temp=0;
 temp=a[0];a[0]=a[1];a[1]=temp;
 }
 public static void main(String args[]) throws Exception
 {
 int[] a = new int[2];
 System.out.println("输入a:");
 InputStreamReader inreader=new InputStreamReader(System.in);
 BufferedReader breader=new BufferedReader(inreader);
 a[0]=Integer.parseInt(breader.readLine());
 System.out.println("输入b:");
 a[1]=Integer.parseInt(breader.readLine());
 System.out.println("交换前a="+a[0]+" 交换前b="+a[1]);
 change(a);
 System.out.println("交换后a="+a[0]+" 交换后b="+a[1]);
 }
 }


4：这种类性的交换，实属罕见。很经典的，如果谁知道请帮忙解释一下。

public class Test
 {   
   public static void main(String[]args)
   {
         int a=10;
         int b=5;
      System.out.println((a=(b+(b=a)*0))+"b:"+b);
    }


}