Java编程思想第4版[中文版](PDF格式)-第53部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
//： Month2。java
// A more robust enumeration system
package c07；
public final class Month2 ｛
private String name；
private Month2（String nm） ｛ name = nm； ｝
public String toString（） ｛ return name； ｝
public final static Month2
JAN = new Month2（〃January〃）；
FEB = new Month2（〃February〃）；
MAR = new Month2（〃March〃）；
APR = new Month2（〃April〃）；
MAY = new Month2（〃May〃）；
JUN = new Month2（〃June〃）；
JUL = new Month2（〃July〃）；
AUG = new Month2（〃August〃）；
SEP = new Month2（〃September〃）；
OCT = new Month2（〃October〃）；
NOV = new Month2（〃November〃）；
DEC = new Month2（〃December〃）；
public final static Month2＇＇ month = ｛
JAN； JAN； FEB； MAR； APR； MAY； JUN；
JUL； AUG； SEP； OCT； NOV； DEC
｝；
public static void main（String＇＇ args） ｛
177
…………………………………………………………Page 179……………………………………………………………
Month2 m = Month2。JAN；
System。out。println（m）；
m = Month2。month＇12＇；
System。out。println（m）；
System。out。println（m == Month2。DEC）；
System。out。println（m。equals（Month2。DEC））；
｝
｝ ///：~
①：是 Rich Hoffarth 的一封E…mail 触发了我这样编写程序的灵感。
这个类叫作 Month2，因为标准 Java 库里已经有一个Month。它是一个 final 类，并含有一个private 构建
器，所以没有人能从它继承，或制作它的一个实例。唯一的实例就是那些 final static对象，它们是在类本
身内部创建的，包括：JAN，FEB，MAR 等等。这些对象也在month 数组中使用，后者让我们能够按数字挑选
月份，而不是按名字（注意数组中提供了一个多余的JAN，使偏移量增加了 1，也使 December 确实成为 12
月）。在main（）中，我们可注意到类型的安全性：m 是一个 Month2 对象，所以只能将其分配给Month2。在
前面的Months。java 例子中，只提供了 int值，所以本来想用来代表一个月份的 int 变量可能实际获得一个
整数值，那样做可能不十分安全。
这儿介绍的方法也允许我们交换使用==或者equals（），就象main（）尾部展示的那样。
7。5。4 初始化接口中的字段
接口中定义的字段会自动具有 static 和final 属性。它们不能是“空白 final”，但可初始化成非常数表达
式。例如：
//： RandVals。java
// Initializing interface fields with
// non…constant initializers
import java。util。*；
public interface RandVals ｛
int rint = （int）（Math。random（） * 10）；
long rlong = （long）（Math。random（） * 10）；
float rfloat = （float）（Math。random（） * 10）；
double rdouble = Math。random（） * 10；
｝ ///：~
由于字段是 static 的，所以它们会在首次装载类之后、以及首次访问任何字段之前获得初始化。下面是一个
简单的测试：
//： TestRandVals。java
public class TestRandVals ｛
public static void main（String＇＇ args） ｛
System。out。println（RandVals。rint）；
System。out。println（RandVals。rlong）；
System。out。println（RandVals。rfloat）；
System。out。println（RandVals。rdouble）；
｝
｝ ///：~
当然，字段并不是接口的一部分，而是保存于那个接口的 static存储区域中。
178
…………………………………………………………Page 180……………………………………………………………
7。6 内部类
在Java 1。1 中，可将一个类定义置入另一个类定义中。这就叫作“内部类”。内部类对我们非常有用，因为
利用它可对那些逻辑上相互联系的类进行分组，并可控制一个类在另一个类里的“可见性”。然而，我们必
须认识到内部类与以前讲述的“合成”方法存在着根本的区别。
通常，对内部类的需要并不是特别明显的，至少不会立即感觉到自己需要使用内部类。在本章的末尾，介绍
完内部类的所有语法之后，大家会发现一个特别的例子。通过它应该可以清晰地认识到内部类的好处。
创建内部类的过程是平淡无奇的：将类定义置入一个用于封装它的类内部（若执行这个程序遇到麻烦，请参
见第3 章的3。1。2 小节“赋值”）：
//： Parcel1。java
// Creating inner classes
package c07。parcel1；
public class Parcel1 ｛
class Contents ｛
private int i = 11；
public int value（） ｛ return i； ｝
｝
class Destination ｛
private String label；
Destination（String whereTo） ｛
label = whereTo；
｝
String readLabel（） ｛ return label； ｝
｝
// Using inner classes looks just like
// using any other class； within Parcel1：
public void ship（String dest） ｛
Contents c = new Contents（）；
Destination d = new Destination（dest）；
｝
public static void main（String＇＇ args） ｛
Parcel1 p = new Parcel1（）；
p。ship（〃Tanzania〃）；
｝
｝ ///：~
若在 ship（）内部使用，内部类的使用看起来和其他任何类都没什么分别。在这里，唯一明显的区别就是它的
名字嵌套在 Parcel1 里面。但大家不久就会知道，这其实并非唯一的区别。
更典型的一种情况是，一个外部类拥有一个特殊的方法，它会返回指向一个内部类的句柄。就象下面这样：
//： Parcel2。java
// Returning a handle to an inner class
package c07。parcel2；
public class Parcel2 ｛
class Contents ｛
private int i = 11；
public int value（） ｛ return i； ｝
｝
class Destination ｛
private String label；
179
…………………………………………………………Page 181……………………………………………………………
Destination（String whereTo） ｛
label = whereTo；
｝
String readLabel（） ｛ return label； ｝
｝
public Destination to（String s） ｛
return new Destination（s）；
｝
public Contents cont（） ｛
return new Contents（）；
｝
public void ship（String dest） ｛
Contents c = cont（）；
Destination d = to（dest）；
｝
public static void main（String＇＇ args） ｛
Parcel2 p = new Parcel2（）；
p。ship（〃Tanzania〃）；
Parcel2 q = new Parcel2（）；
// Defining handles to inner classes：
Parcel2。Contents c = q。cont（）；
Parcel2。Destination d = q。to（〃Borneo〃）；
｝
｝ ///：~
若想在除外部类非 static 方法内部之外的任何地方生成内部类的一个对象，必须将那个对象的类型设为“外
部类名。内部类名”，就象main（）中展示的那样。
7。6。1 内部类和上溯造型
迄今为止，内部类看起来仍然没什么特别的地方。毕竟，用它实现隐藏显得有些大题小做。Java 已经有一个
非常优秀的隐藏机制——只允许类成为“友好的”（只在一个包内可见），而不是把它创建成一个内部类。
然而，当我们准备上溯造型到一个基础类（特别是到一个接口）的时候，内部类就开始发挥其关键作用（从
用于实现的对象生成一个接口句柄具有与上溯造型至一个基础类相同的效果）。这是由于内部类随后可完全
进入不可见或不可用状态——对任何人都将如此。所以我们可以非常方便地隐藏实施细节。我们得到的全部
回报就是一个基础类或者接口的句柄，而且甚至有可能不知道准确的类型。就象下面这样：
//： Parcel3。java
// Returning a handle to an inner class
package c07。parcel3；
abstract class Contents ｛
abstract public int value（）；
｝
interface Destination ｛
String readLabel（）；
｝
public class Parcel3 ｛
private class PContents extends Contents ｛
private int i = 11；
public int value（） ｛ return i； ｝
180
…………………………………………………………Page 182……………………………………………………………
｝
protected class PDestination
implements Destination ｛
private String label；
private PDestination（String whereTo） ｛
label = whereTo；
｝
public String readLabel（） ｛ return label； ｝
｝
public Destination dest（String s） ｛
return new PDestination（s）；
｝
public Contents cont（） ｛
return new PContents（）；
｝
｝
class Test ｛
public static void main（String＇＇ args） ｛
Parcel3 p = new Parcel3（）；
Contents c = p。cont（）；
Destination d = p。dest（〃Tanzania〃）；
// Illegal …can't access private class：
//！ Parcel3。PContents c = p。new PContents（）；
｝
｝ ///：~
现在，Contents 和Destination 代表可由客户程序员使用的接口（记住接口会将自己的所有成员都变成
public 属性）。为方便起见，它们置于单独一个文件里，但原始的 Contents 和Destination 在它们自己的
文件中是相互public 的。
在Parcel3 中，一些新东西已经加入：内部类PContents 被设为 private，所以除了Parcel3 之外，其他任
何东西都不能访问它。PDestination 被设为 protected，所以除了 Parcel3，Parcel3 包内的类（因为
protected 也为包赋予了访问权；也就是说，protected 也是“友好的”），以及Parcel3 的继承者之外，其
他任何东西都不能访问 PDestination。这意味着客户程序员对这些成员的认识与访问将会受到限制。事实
上，我们甚至不能下溯造型到一个 private 内部类（或者一个protected 内部类，除非自己本身便是一个继
承者），因为我们不能访问名字，就象在 classTest 里看到的那样。所以，利用private 内部类，类设计人
员可完全禁止其他人依赖类型编码，并可将具体的实施细节完全隐藏起来。除此以外，从客户程序员的角度
来看，一个接口的范围没有意义的，因为他们不能访问不属于公共接口类的任何额外方法。这样一来，Java
编译器也有机会生成效率更高的代码。
普通（非内部）类不可设为private 或 protected——只允许 public 或者“友好的”。
注意Contents 不必成为一个抽象类。在这儿也可以使用一个普通类，但这种设计最典型的起点依然是一个
“接口”。
7。6。2 方法和作用域中的内部类
至此，我们已基本理解了内部类的典型用途。对那些涉及内部类的代码，通常表达的都是“单纯”的内部
类，非常简单，且极易理解。然而，内部类的设计非常全面，不可避免地会遇到它们的其他大量用法——假
若我们在一个方法甚至一个任意的作用域内创建内部类。有两方面的原因促使我们这样做：
（1） 正如前面展示的那样，我们准备实现某种形式的接口，使自己能创建和返回一个句柄。
（2） 要解决一个复杂的问题，并希望创建一个类，用来辅助自己的程序方案。同时不愿意把它公开。
在下面这个例子里，将修改前面的代码，以便使用：
（1） 在一个方法内定义的类
181
…………………………………………………………Page 183……………………………………………………………
（2） 在方法的一个作用域内定义的类
（3） 一个匿名类，用�
