将引用传递进入一个方法时，指向的仍然是相同的对象。一个简单的实验可以证明这一点（若执行这个程序时有麻烦，请参考第3章3.1.2小节“赋值”）：

  1. //: PassHandles.java
  2. // Passing handles around
  3. package c12;
  5. public class PassHandles {
  6.   static void f(PassHandles h) {
  7.     System.out.println("h inside f(): " + h);
  8.   }
  9.   public static void main(String[] args) {
  10.     PassHandles p = new PassHandles();
  11.     System.out.println("p inside main(): " + p);
  12.     f(p);
  13.   }
  14. } ///:~

toString方法会在打印语句里自动调用，而PassHandles直接从Object继承，没有toString的重新定义。因此，这里会采用toString的Object版本，打印出对象的类，接着是那个对象所在的位置（不是引用，而是对象的实际存储位置）。输出结果如下：

  1. p inside main(): PassHandles@1653748
  2. h inside f() : PassHandles@1653748

可以看到，无论p还是h引用的都是同一个对象。这比复制一个新的PassHandles对象有效多了，使我们能将一个参数发给一个方法。但这样做也带来了另一个重要的问题。

12.1.1 别名问题

“别名”意味着多个引用都试图指向同一个对象，就象前面的例子展示的那样。若有人向那个对象里写入一点什么东西，就会产生别名问题。若其他引用的所有者不希望那个对象改变，恐怕就要失望了。这可用下面这个简单的例子说明：

  1. //: Alias1.java
  2. // Aliasing two handles to one object
  4. public class Alias1 {
  5.   int i;
  6.   Alias1(int ii) { i = ii; }
  7.   public static void main(String[] args) {
  8.     Alias1 x = new Alias1(7);
  9.     Alias1 y = x; // Assign the handle
  10.     System.out.println("x: " + x.i);
  11.     System.out.println("y: " + y.i);
  12.     System.out.println("Incrementing x");
  13.     x.i++;
  14.     System.out.println("x: " + x.i);
  15.     System.out.println("y: " + y.i);
  16.   }
  17. } ///:~

对下面这行：

  1. Alias1 y = x; // Assign the handle

它会新建一个Alias1引用，但不是把它分配给由new创建的一个新鲜对象，而是分配给一个现有的引用。所以引用x的内容——即对象x指向的地址——被分配给y，所以无论x还是y都与相同的对象连接起来。这样一来，一旦x的i在下述语句中自增：

  1. x.i++;

y的i值也必然受到影响。从最终的输出就可以看出：

  1. x: 7
  2. y: 7
  3. Incrementing x
  4. x: 8
  5. y: 8

此时最直接的一个解决办法就是干脆不这样做：不要有意将多个引用指向同一个作用域内的同一个对象。这样做可使代码更易理解和调试。然而，一旦准备将引用作为一个变量或参数传递——这是Java设想的正常方法——别名问题就会自动出现，因为创建的本地引用可能修改“外部对象”（在方法作用域之外创建的对象）。下面是一个例子：

  1. //: Alias2.java
  2. // Method calls implicitly alias their
  3. // arguments.
  5. public class Alias2 {
  6.   int i;
  7.   Alias2(int ii) { i = ii; }
  8.   static void f(Alias2 handle) {
  9.     handle.i++;
  10.   }
  11.   public static void main(String[] args) {
  12.     Alias2 x = new Alias2(7);
  13.     System.out.println("x: " + x.i);
  14.     System.out.println("Calling f(x)");
  15.     f(x);
  16.     System.out.println("x: " + x.i);
  17.   }
  18. } ///:~

输出如下：

  1. x: 7
  2. Calling f(x)
  3. x: 8

方法改变了自己的参数——外部对象。一旦遇到这种情况，必须判断它是否合理，用户是否愿意这样，以及是不是会造成问题。

通常，我们调用一个方法是为了产生返回值，或者用它改变为其调用方法的那个对象的状态（方法其实就是我们向那个对象“发一条消息”的方式）。很少需要调用一个方法来处理它的参数；这叫作利用方法的“副作用”（Side Effect）。所以倘若创建一个会修改自己参数的方法，必须向用户明确地指出这一情况，并警告使用那个方法可能会有的后果以及它的潜在威胁。由于存在这些混淆和缺陷，所以应该尽量避免改变参数。

若需在一个方法调用期间修改一个参数，且不打算修改外部参数，就应在自己的方法内部制作一个副本，从而保护那个参数。本章的大多数内容都是围绕这个问题展开的。