在Java里应用另类的指针

众所周知，在Java编程语言里是没有类似C/C++里头的指针（Pointer）的。

比如，以下的代码，以C/C++来呈现的话肯定没问题。
但如果以Java来编写，那就得不到我们所要求的结果了。
void Swap(int num1, int num2)  //数字对调函数
{
    int tmp=num1;
    num1=num2;
    num2=tmp;
}

运行的指令：
int n1=10;
int n2=20;
System.out.printf("Before:n1=%d,n2=%d\n",n1,n2);
Swap(n1,n2);
System.out.printf("After :n1=%d,n2=%d\n",n1,n2);

输出结果：
Before:n1=10,n2=20
After :n1=10,n2=20

不过，这个问题是可以用另一种方式解决。
尽管Java在创造时就已经排除掉指针（pointer）这个非常好用的功能，
但是，它还是保留了类似指针功能的reference。
因为Java的array与object都是以reference来表示的。
Java的reference就像C++里的reference （&）一样。
只要善加利用以及加上编程的技巧，就能达到指针的功效了。

public class Main {
    public static void main(String[] args) {
        int[] n1=NewInt(10);
        int[] n2=NewInt(20);
        System.out.printf("Before:n1=%d,n2=%d\n",Value(n1),Value(n2));
        Swap(n1,n2);
        System.out.printf("After :n1=%d,n2=%d\n",Value(n1),Value(n2));
    }

    public static void Swap(int[] num1, int[] num2) {
        int tmp=num1[0];
        num1[0]=num2[0];
        num2[0]=tmp;
    }

    public static int[] NewInt(int value) {
        int[] array=new int[1];
        array[0]=value;
        return array;
    }

    public static int Value(int[] array) {
        return array[0];
    }
}

输出结果：
Before:n1=10,n2=20
After :n1=20,n2=10

这个现象是可以更加的发扬光大到类的物件的。
比如：

class IOBuf {
    public int buffer;
    public IOBuf() {
        buffer=0;
    }
}

class IO {
    public int Addr;
    public int Bit;
    public IOBuf rBuf;
   
    public IO(int addr, int bit, IOBuf buf) {
        Addr=addr;
        Bit=bit;
        rBuf=buf;
    }

    public void SetOn() {
        rBuf.buffer|=Bit;
    }

    public void SetOff() {
        rBuf.buffer&=0xffff-Bit;
    }
}

  运行的指令：
  IOBuf buf1=new IOBuf();
  IOBuf buf2=new IOBuf()
  IO[] BitTable={ new IO(0x200,0x0001,buf1),
                  new IO(0x200,0x0002,buf1)
                  new IO(0x201,0x0001,buf2)
                  new IO(0x201,0x0002,buf2)
                 };
  MyIO=BitTable.clone();

  MyIO[0].SetOff();
  MyIO[1].SetOn();
  MyIO[2].SetOn();
  MyIO[3].SetOff();
  System.out.printf("%d,%d\n",buf1.buffer,buf2.buffer);
  System.out.printf("%d,%d,\n",MyIO[0].rBuf.buffer,MyIO[1].rBuf.buffer);
  System.out.printf("%d,%d,\n",MyIO[2].rBuf.buffer,MyIO[3].rBuf.buffer);
  System.out.printf("\n");

  MyIO[0].SetOn();
  MyIO[1]SetOff();
  MyIO[2].SetOff();
  MyIO[3]SetOn();
  System.out.printf("%d,%d\n",buf1.buffer,buf2.buffer);
  System.out.printf("%d,%d\n",MyIO[0].rBuf.buffer,MyIO[1].rBuf.buffer);
  System.out.printf("%d,%d\n",MyIO[2].rBuf.buffer,MyIO[3].rBuf.buffer);

在这里，BitTable是local（本地）的变量，而MyIO是global（全局）的变量。
上述的代码是方便初始化IO[]里的参数。

输出结果：
2,1
2,2
1,1

1,2
1,1
2,2

也就是说MyIO[0].rBuf.buffer与MyIO[1].rBuf.buffer是指向buf1.buffer，
而MyIO[2].rBuf.buffer与MyIO[3].rBuf.buffer则是指向buf2.buffer的。

其实这个“漏洞”，当我在学Python时就发现了，没想到Java也是一样的。