2.9　引用类型

至此，我们已经介绍了数组、类和对象，接下来可以介绍更一般的引用类型了。类和数组是 Java 五种引用类型中的两种。前面已经介绍了类，第 3 章会全面详细地说明类和接口。枚举和注解这两种引用类型在第 4 章介绍。

本节不涉及任何引用类型的具体句法，而是说明引用类型的一般行为，还会说明引用类型和基本类型的区别。本节使用术语“对象”指代引用类型（包括数组）的值或实例。

2.9.1　引用类型与基本类型比较

引用类型和对象与基本类型和基本值有本质的区别。

  • 八种基本类型由 Java 语言定义，程序员不能定义新基本类型。引用类型由用户定义，因此有无限多个。例如，程序可以定义一个名为 Point 的类，然后使用这个新定义类型的对象存储和处理笛卡儿坐标系中的 (x, y) 点。

  • 基本类型表示单个值。引用类型是聚合类型（aggregate type），可以保存零个或多个基本值或对象。例如，我们假设的 Point 类可能存储了两个 double 类型的值，表示点的 x 和 y 坐标。char[] 和 Point[] 数组类型是聚合类型，因为它们保存一些 char 类型的基本值或 Point 对象。

  • 基本类型需要一到八个字节的内存空间。把基本值存储到变量中，或者传入方法时，计算机会复制表示这个值的字节。而对象基本上需要更多的内存。创建对象时会在堆（heap）中动态分配内存，存储这个对象；如果不再需要使用这个对象了，存储它的内存会被自动垃圾回收。

2.9　引用类型 - 图1　把对象赋值给变量或传入方法时，不会复制表示这个对象的内存，而是把这个内存的引用存储在变量中或传入方法。

在 Java 中，引用完全不透明，引用的表示方式由 Java 运行时的实现细节决定。如果你是 C 程序员的话，完全可以把引用看作指针或内存地址。不过要记住，Java 程序无法使用任何方式处理引用。

与 C 和 C++ 中的指针不同的是，引用不能转换成整数，也不能把整数转换成引用，而且不能递增或递减。C 和 C++ 程序员还要注意，Java 不支持求地址运算符 &，也不支持解除引用运算符 * 和 ->。

2.9.2　处理对象和引用副本

下述代码处理 int 类型基本值：

  1. int x = 42;
  2. int y = x;

执行这两行代码后，变量 y 中保存了变量 x 中所存值的一个副本。在 Java 虚拟机内部，这个 32 位整数 42 有两个独立的副本。

现在，想象一下把这段代码中的基本类型换成引用类型后再运行会发生什么：

  1. Point p = new Point(1.0, 2.0);
  2. Point q = p;

运行这段代码后，变量 q 中保存了一份变量 p 中所存引用的一个副本。在虚拟机中，仍然只有一个 Point 对象的副本，但是这个对象的引用有两个副本——这一点有重要的含义。假设上面两行代码的后面是下述代码：

  1. System.out.println(p.x);  // 打印p的x坐标：1.0
  2. q.x = 13.0;               // 现在，修改q的x坐标
  3. System.out.println(p.x);  // 再次打印p.x，这次得到的值是13.0

因为变量 p 和 q 保存的引用指向同一个对象，所以两个变量都可以用来修改这个对象，而且一个变量中的改动在另一个变量中可见。数组也是一种对象，所以对数组来说也会发生同样的事，如下面的代码所示：

  1. // greet保存一个数组的引用
  2. char[] greet = { 'h','e','l','l','o' };
  3. char[] cuss = greet;             // cuss保存的是同一个数组的引用
  4. cuss[4] = '!';                   // 使用引用修改一个元素
  5. System.out.println(greet);       // 打印“hell!”

把基本类型和引用类型的参数传入方法时也有类似的区别。假如有下面的方法：

  1. void changePrimitive(int x) {
  2.     while(x > 0) {
  3.         System.out.println(x--);
  4.     }
  5. }

调用这个方法时，会把实参的副本传给形参 x。在这个方法的代码中，x 是循环计数器，向零递减。因为 x 是基本类型，所以这个方法有这个值的私有副本——这是完全合理的做法。

可是，如果把这个方法的参数改为引用类型，会发生什么呢？

  1. void changeReference(Point p) {
  2.     while(p.x > 0) {
  3.         System.out.println(p.x--);
  4.     }
  5. }

调用这个方法时，传入的是一个 Point 对象引用的私有副本，然后使用这个引用修改对应的 Point 对象。例如，有下述代码：

  1. Point q = new Point(3.0, 4.5); // 一个x坐标为3的点
  2. changeReference(q);            // 打印3，2，1，而且修改了这个Point对象
  3. System.out.println(q.x);       // 现在，q的x坐标是0！

调用 changeReference() 方法时，传入的是变量 q 中所存引用的副本。现在，变量 q 和方法的形参 p 保存的引用指向同一个对象。这个方法可以使用它的引用修改对象的内容。但是要注意，这个方法不能修改变量 q 的内容。也就是说，这个方法可以随意修改引用的 Point 对象，但不能改变变量 q 引用这个对象这一事实。

2.9.3　比较对象

我们已经介绍了基本类型和引用类型在赋值给变量、传入方法和复制时的显著区别。这两种类型在相等性比较时也有区别。相等运算符（==）比较基本值时，只测试两个值是否一样（即每一位的值都完全相同）。而 == 比较引用类型时，比较的是引用而不是真正的对象。也就是说，== 测试两个引用是否指向同一个对象，而不测试两个对象的内容是否相同。例如：

  1. String letter = "o";
  2. String s = "hello";              // 这两个String对象
  3. String t = "hell" + letter;      // 保存的文本完全一样
  4. if (s == t) System.out.println("equal"); // 但是，二者并不相等！
  6. byte[] a = { 1, 2, 3 };
  7. // 内容一样的副本
  8. byte[] b = (byte[]) a.clone();
  9. if (a == b) System.out.println("equal"); // 但是，二者并不相等！

对引用类型来说，有两种相等：引用相等和对象相等。一定要把这两种相等区分开。其中一种方式是，使用“相同”（identical）表示引用相等，使用“相等”（equal）表示对象的内容一样。若想测试两个不同的对象是否相等，可以在一个对象上调用 equals() 方法，然后把另一个对象传入这个方法：

  1. String letter = "o";
  2. String s = "hello";              // 这两个String对象
  3. String t = "hell" + letter;      // 保存的文本完全一样
  4. if (s.equals(t)) {               // equals()方法
  5.     System.out.println("equal"); // 证实了这一点
  6. }

所有对象都（从 Object 类）继承了 equals() 方法，但是默认的实现方式是使用 == 测试引用是否相同，而不测试内容是否相等。想比较对象是否相等的类可以自定义 equals() 方法。Point 类没自定义，但 String 类自定义了，如前面的例子所示。可以在数组上调用 equals() 方法，但作用和使用 == 运算符一样，因为数组始终继承默认的 equals() 方法，比较引用而不是数组的内容。比较数组是否相等可以使用 java.util.Arrays.equals() 实用方法。

2.9.4　装包和拆包转换

基本类型和引用类型的表现完全不同。有时需要把基本值当成对象，为此，Java 平台为每一种基本类型都提供了包装类。Boolean、Byte、Short、Character、Integer、Long、Float 和 Double 是不可变的最终类，每个实例只保存一个基本值。包装类一般在把基本值存储在集合中时使用，例如 java.util.List：

  1. // 创建一个List集合
  2. List numbers = new ArrayList();
  3. // 存储一个包装类表示的基本值
  4. numbers.add(new Integer(-1));
  5. // 取出这个基本值
  6. int i = ((Integer)numbers.get(0)).intValue();

Java 支持装包和拆包类型转换。装包转换把一个基本值转换成对应的包装对象，而拆包转换的作用相反。虽然可以通过校正显式指定装包和拆包转换，但没必要这么做，因为把值赋值给变量或传入方法时会自动执行这种转换。此外，如果把包装对象传给需要基本值的 Java 运算符或语句，也会自动执行拆包转换。因为 Java 能自动执行装包和拆包转换，所以这种语言特性一般叫作自动装包（autoboxing）。

下面是一些自动装包和拆包转换的示例：

  1. Integer i = 0;   // 把int类型字面量0装包到Integer对象中
  2. Number n = 0.0f; // 把float类型字面量装包到Float对象中，然后放大转换成Number类型
  3. Integer i = 1;   // 这是装包转换
  4. int j = i;       // i在这里拆包
  5. i++;             // 拆包i，递增，再装包
  6. Integer k = i+2; // 拆包i，再装包两数之和
  7. i = null;
  8. j = i;           // 这次拆包抛出NullPointerException异常

自动装包也把集合处理变得更简单了。下面这个示例，使用 Java 的泛型（4.2 节专门介绍这个语言特性）限制列表和其他集合中能存储什么类型的值：

  1. List<Integer> numbers = new ArrayList<>(); // 创建一个由整数组成的列表
  2. numbers.add(-1);                           // 把int类型的值装包到Integer对象中
  3. int i = numbers.get(0);                    // 把Integer对象拆包成int类型