谜题75：头还是尾

这个程序的行为在 1.4 版和 5.0 版的 Java 平台上会有些变化。这个程序在这些版本上会分别
做些什么呢？（如果你只能访问 5.0 版本的平台，那么你可以在编译的时候使用-source 1.4
标记，以此来模拟 1.4 版的行为。）

import java.util.Random;
public class CoinSide {

private static Random rnd = new Random();
public static CoinSide flip() {
return rnd.nextBoolean() ?
Heads.INSTANCE : Tails.INSTANCE;
}
public static void main(String[ ] args) {
System.out.println(flip());
}
}
class Heads extends CoinSide {
private Heads() { }
public static final Heads INSTANCE = new Heads();
public String toString() {
return "heads";
}
}
class Tails extends CoinSide {
private Tails() { }
public static final Tails INSTANCE = new Tails();
public String toString() {
return "tails";
}
}

　　

该程序看起来根本没有使用 5.0 版的任何新特性，因此很难看出来为什么它们在
行为上应该有差异。事实上，该程序在 1.4 或更早版本的平台上是不能编译的：

CoinSide.java:7:
incompatible types for ?: neither is a subtype of the other
second operand: Heads
third operand : Tails
return rnd.nextBoolean() ?

条件操作符（？:）的行为在 5.0 版本之前是非常受限的[JLS2 15.25]。当第二
个和第三个操作数是引用类型时，条件操作符要求它们其中的一个必须是另一个
的子类型。Heads 和 Tails 彼此都不是对方的子类型，所以这里就产生了一个错
误。为了让这段代码能够编译，你可以将其中一个操作数转型为二者的公共超类：

return rnd.nextBooleam() ?
(CoinSide)Heads.INSTANCE : Tails.INSTANCE;

在 5.0 或更新的版本中，Java 语言显得更加宽大了，条件操作符在第二个和第
三个操作数是引用类型时总是合法的。其结果类型是这两种类型的最小公共超
类。公共超类总是存在的，因为 Object 是每一个对象类型的超类型。在实际使
用中，这种变化的主要结果就是条件操作符做正确的事情的情况更多了，而给出
编译期错误的情况更少了。对于我们当中的语言菜鸟来说，作用于引用类型的条
件操作符的结果所具备的编译期类型与在第二个和第三个操作数上调用下面的
方法的结果相同：

T choose(T a,T b) { }

本谜题所展示的问题在 1.4 和更早的版本中发生得相当频繁，迫使你必须插入只
是为了遮掩你的代码的真实目的而进行的转型。这就是说，该谜题本身是人为制
造的。在 5.0 版本之前，使用类型安全的枚举模式来编写 CoinSide 对程序员来
说会显得更自然一些[EJ Item 21]：

import java.util.Random;
public class CoinSide {
public static final CoinSide HEADS = new CoinSide("heads");
public static final CoinSide TAILS = new CoinSide("tails");
private final String name;
private CoinSide(String name) {
this.name = name;
}
public String toString() {
return name;
}
private static Random rnd = new Random();
public static CoinSide flip() {
return rnd.nextBoolean() ? HEADS : TAILS;
}
public static void main(String[] args) {
System.out.println(flip());
}
}

在 5.0 或更新的版本中，自然会将 CoinSide 当作是一个枚举类型来编写：

public enum CoinSide {
HEADS, TAILS;
public String toString() {

return name().toLowerCase();
}
// flip 和 main 与上面的 1.4 版上的实现一样
}

　　

本谜题的教训是：应该升级到最新的 Java 平台版本上。较新的版本都包含许多
让程序员更轻松的改进，你并不需要费力去学习怎样利用所有的新特性，有些新
特性不需要你付出任何努力就可以给你带来实惠。对语言和类库的设计者来说，
得到的教训是：不要让程序员去做那些语言或类库本可以帮他们做的事。

名字重用的术语表

覆写 （override ）
一个实例方法可以覆写（override）在其超类中可访问到的具有相同签名的所有实例方法[JLS
8.4.8.1]，从而使能了动态分派（dynamic dispatch）；换句话说，VM 将基于实例的运行期类
型来选择要调用的覆写方法[JLS 15.12.4.4]。覆写是面向对象编程技术的基础，并且是唯一
没有被普遍劝阻的名字重用形式：

class Base {
public void f() { }
}
class Derived extends Base {
public void f() { } // overrides Base.f()
}

　　

隐藏 （hide ）
一个域、静态方法或成员类型可以分别隐藏（hide）在其超类中可访问到的具有相同名字（对
方法而言就是相同的方法签名）的所有域、静态方法或成员类型。隐藏一个成员将阻止其被
继承[JLS 8.3, 8.4.8.2, 8.5]：

class Base {
public static void f() { }
}
class Derived extends Base {
private static void f() { } // hides Base.f()
}

　　

重载 （overload ）
在某个类中的方法可以重载（overload）另一个方法，只要它们具有相同的名字和不同的签
名。由调用所指定的重载方法是在编译期选定的[JLS 8.4.9, 15.12.2]：

class CircuitBreaker {
public void f(int i) { } // int overloading
public void f(String s) { } // String overloading
}

　　

遮蔽 （shadow ）
一个变量、方法或类型可以分别遮蔽（shadow）在一个闭合的文本范围内的具有相同名字
的所有变量、方法或类型。如果一个实体被遮蔽了，那么你用它的简单名是无法引用到它的；
根据实体的不同，有时你根本就无法引用到它[JLS 6.3.1]：

class WhoKnows {
static String sentence = "I don't know.";
public static woid main(String[ ] args) {
String sentence = “I know!”; // shadows static field
System.out.println(sentence); // prints local variable
}
}

　　

尽管遮蔽通常是被劝阻的，但是有一种通用的惯用法确实涉及遮蔽。构造器经常
将来自其所在类的某个域名重用为一个参数，以传递这个命名域的值。这种惯用
法并不是没有风险，但是大多数 Java 程序员都认为这种风格带来的实惠要超过
其风险：

class Belt {
private final int size;
public Belt(int size) { // Parameter shadows Belt.size
this.size = size;
}
}

　　

遮掩 （obscure ）
一个变量可以遮掩具有相同名字的一个类型，只要它们都在同一个范围内：如果这个名字被
用于变量与类型都被许可的范围，那么它将引用到变量上。相似地，一个变量或一个类型可
以遮掩一个包。遮掩是唯一一种两个名字位于不同的名字空间的名字重用形式，这些名字空
间包括：变量、包、方法或类型。如果一个类型或一个包被遮掩了，那么你不能通过其简单
名引用到它，除非是在这样一个上下文环境中，即语法只允许在其名字空间中出现一种名字。
遵守命名习惯就可以极大地消除产生遮掩的可能性[JLS 6.3.2, 6.5]：

public class Obscure {
static String System; // Obscures type java.lang.System
public static void main(String[ ] args) {
// Next line won't compile: System refers to static field
System.out.println(“hello, obscure world!”);
}
}