java 嵌套类

为什么Java支持类嵌套？
Java并非一定要支持类嵌套。实际上，如果你看过内部类规范文档，你将会发现类嵌套的应用 在哪里。不过，Java支持类嵌套至少有两个好处：
.令源代码更加清晰
.减少命名的冲突
通过类嵌套可以令源代码变得更为清楚，因为你声明了一个包含有一些对象的类，它必须可以 管理和允许类中的方法来直接访问对象的字段，以及调用对象的方法--即使是外部类中的私有字段和 方法。要理解这个好处，可用以下的一个例子说明，在这个程序中要循环遍历一个Employee对象中 的Job对象：
public Object nextJob() {
return !hasMoreJobs() ? null : jobs[jobIndex++]; } } }
s JobIterator3 {
public static void main(String[] args) {
Job[] jobs = { new Job("Janitor"), new Job("Delivery Person") };
class JobIterator1 {
public static void main(String[] args) {
Job[] jobs ={ new Job("Janitor"), new Job("Delivery Person") };
Employee1 e = new Employee1("John Doe", jobs);
Employee e = new Employee("John Doe", jobs);
System.out.println(e.getName() + " works the following jobs:\n");
Employee.JobIterator eji = e.getJobIterator();
return jobTitle; } }
class Employee {
private String name; private Job [] jobs; private int jobIndex = 0;
Employee (String name, Job [] jobs) {
= name; this.jobs = jobs; }
String getName () {
return name; }
boolean hasMoreJobs () {
return jobIndex < jobs.length;
}
Job nextJob () {
return !hasMoreJobs () ? null : jobs [jobIndex++]; } }
Listing 2. JobIterator2.java
// JobIterator2.java
class Job {
private String jobTitle;
public Job (String jobTitle) {
this.jobTitle = jobTitle; }
public String toString () {
摘要：与字段和方法类似，Java允许类是其它类的成员。在这里，我们将嵌套类分为4种--嵌套顶 级类（nested top-level classes），成员内部 类（instance inner classes），本地内部类（local inner classes）和匿名内部类（anonymous inner classes）。
John Doe works the following jobs:
Janitor Delivery Person
JobIterator1包含有Job, Employee和JobIterator1类。Job封装了一个job的title，而Employee 封装了一个员工的名字以及该员工所做工作的一个数组。JobIterator1包含有一个main()的方法用 来创建Job和Employee对象，并且打印出该员工的名字和工作。
} }
为什么Java支持类嵌套，还有Java支持哪些类嵌套？以下的部分将会回答这些问题，当你读完 这篇文章，你就会学习到类嵌套的相关知识，并且运用它来写出强大的Java程序。首先我们先来看 一下为什么Java支持类嵌套。
注意：在发布JDK1.1后，Sun发布了内部类规范的文档。该文档谈到嵌套顶级类和内部类的运用。 在读完这篇文章后，我强烈建议你浏览这些文档。
Employee(String name, Job[] jobs) {
= name; this.jobs = jobs; }
String getName() {
return name; }
JobIterator getJobIterator() {
return new JobIterator(jobs); } }
Listing 1. JobIterator1.java
// JobIterator1.java
class Job {
private String jobTitle;
public Job (String jobTitle) {
this.jobTitle = jobTitle; }
public String toString () {
在教授Java时，我经常发现学生尝试在方法中声明其它的方法。不过，与Pascal语言不同 --Pascal允许嵌套声明过程procedures（与方法类似），而Java是不允许这样做的。对于以下的代 码，尝试在outerMethod()中声明innerMethod()方法，编译时将会通不过。
void outerMethod () {
while (eji.hasMoreJobs()) System.out.println(eji.nextJob());
} }
JobIterator3的输出和JobIterator1、JobIterator2的一样，它使用了类嵌套：Employee类包 含有JobIterator类的声明。这样做的结果是，JobIterator不再需要一个构造器，因为JobIterator 可直接访问Employee的私有字段job。还有，在JobIterator3的main()方法中，如果需要访问 JobIterator，你都要加入一个Employee前缀。由于JobIterator3的JobIterator类不再需要一个构 造器和自己的jobs字段，因此源代码要比JobIterator2的清楚一些。
return name; }
JobIterator getJobIterator() {
return new JobIterator(); }
class JobIterator {
private int jobIndex = 0;
public boolean hasMoreJobs() {
return jobIndex < jobs.length; }
Listing 3. JobIterator3.java
// JobIterator3.java
class Job {
private String jobTitle;
public Job (String jobTitle) {
this.jobTitle = jobTitle; }
public String toString () {
虽然JobIterator2很方便地解决了JobIterator1的问题，但这个新的程序又引入了一个新问题： 由于新加入了一个和Employee类处在同一级的JobIterator类，这样将来就不能在同一级的源文件中 加入一个普遍的JobIterator接口。因为在源文件的同一级中，你不同拥有同样名字的两个类/接口。 虽然在我们的例子中这不是一个严重的问题，但是在重要的程序中，有些情况下必须在同一个源文 件中使用相同名字的类/接口。要令那些名字共存，你必须认识到一些类完全依赖其它的类。你应该 在其依赖的类中声明这些类。列表3展示了如何在一个Employee类中声明一个JobIterator类 （JobIterator依赖Employee类）。
System.out.println(e.getName() + " works the following jobs:\n");
while (e.hasMoreJobs()) System.out.println(e.nextJob());
} }
运行后, JobIterator1产生如下的输出:
return jobTitle; } }
class Employee {
private String name; private Job[] jobs;
Employee(String name, Job[] jobs) {
= name; this.jobs = jobs; }
String getName() {
return jobIndex < jobs.length; }
Job nextJob() {
return !hasMoreJobs() ? null : jobs[jobIndex++]; } } class Employee { private String name; private Job[] jobs;
class JobIterator2 {
public static void main (String [] args) {
Job [] jobs = { new Job ("Janitor"), new Job ("Delivery Person") };