摘要：与字段和方法类似，java允许类是其它类的成员。在这里，我们将嵌套类分为4种--嵌套顶级类（nested top-level classes），成员内部类（instance inner classes），本地内部类（local inner classes）和匿名内部类（anonymous inner classes）。
　　在教授java时，我经常发现学生尝试在方法中声明其它的方法。不过，与pascal语言不同--pascal允许嵌套声明过程procedures（与方法类似），而java是不允许这样做的。对于以下的代码，尝试在outermethod()中声明innermethod()方法，编译时将会通不过。
　　void outermethod ()
　　{
　　void innermethod ()
　　{
　　}
　　}
　　不过，由java语言规范1.1开始，java就支持类嵌套；java编译器允许一个类出现在另一个类中。以下的代码段就展示了如何在outerclass类中嵌套innerclass类。
　　class outerclass
　　{
　　class innerclass
　　{
　　}
　　}
　　为什么java支持类嵌套，还有java支持哪些类嵌套？以下的部分将会回答这些问题，当你读完这篇文章，你就会学习到类嵌套的相关知识，并且运用它来写出强大的java程序。首先我们先来看一下为什么java支持类嵌套。
　　注意：在发布jdk1.1后，sun发布了内部类规范的文档。该文档谈到嵌套顶级类和内部类的运用。在读完这篇文章后，我强烈建议你浏览这些文档。
　　为什么java支持类嵌套？
　　java并非一定要支持类嵌套。实际上，如果你看过内部类规范文档，你将会发现类嵌套的应用在哪里。不过，java支持类嵌套至少有两个好处：
　　.令源代码更加清晰
　　.减少命名的冲突
　　通过类嵌套可以令源代码变得更为清楚，因为你声明了一个包含有一些对象的类，它必须可以管理和允许类中的方法来直接访问对象的字段，以及调用对象的方法--即使是外部类中的私有字段和方法。要理解这个好处，可用以下的一个例子说明，在这个程序中要循环遍历一个employee对象中的job对象：
　　listing 1. jobiterator1.java
　　// jobiterator1.java
　　class job
　　{
　　private string jobtitle;
　　job (string jobtitle)
　　{
　　this.jobtitle = jobtitle;
　　}
　　public string tostring ()
　　{
　　return jobtitle;
　　}
　　}
　　class employee
　　{
　　private string name;
　　private job [] jobs;
　　private int jobindex = 0;
　　employee (string name, job [] jobs)
　　{
　　this.name = name;
　　this.jobs = jobs;
　　}
　　string getname ()
　　{
　　return name;
　　}
　　boolean hasmorejobs ()
　　{
　　return jobindex < jobs.length;
　　}
　　job nextjob ()
　　{
　　return !hasmorejobs () ? null : jobs [jobindex++];
　　}
　　}
　　class jobiterator1
　　{
　　public static void main (string [] args)
　　{
　　job [] jobs = { new job ("janitor"), new job ("delivery person") };
　　employee e = new employee ("john doe", jobs);
　　system.out.println (e.getname () + " works the following jobs:/n");
　　while (e.hasmorejobs ())
　　system.out.println (e.nextjob ());
　　}
　　}
　　运行后, jobiterator1产生如下的输出:
　　john doe works the following jobs:
　　
　　　　　janitor
　　　　　delivery person
　　jobiterator1包含有job, employee和jobiterator1类。job封装了一个job的title，而employee封装了一个员工的名字以及该员工所做工作的一个数组。jobiterator1包含有一个main()的方法用来创建job和employee对象，并且打印出该员工的名字和工作。
　　employee类中包含有方法hasmorejobs()和nextjob()。这两个方法构成了一个循环。当一个employee对象初始化时，在私有jobs数组中的一个内部索引被设置为0。如果该索引的值比jobs数组的长度少，hasmorejobs()方法返回一个布尔值true。nextjob()使用该索引值由数组中返回一个job对象--并且增加该索引的值，以便下一次调用nextjob()时返回下一个job对象的一个引用。
　　jobiterator1类在设计上有一些问题。首先，在循环结束后你不能重新启动一个循环。当然，你可以很容易地解决这个问题，只要employee类加入一个reset()方法就可以了，该方法将jobindex设置为0。第二个问题更加严重，你不能为一个employee创建多个循环。这是由于hasmorejobs()和nextjob()方法已经写死在employee中了。要解决这两个问题，开发者可以声明一个循环类，它的对象可以循环jobs数组。在循环结束后，程序可以通过创建一个新的循环对象来启动一个新的循环。同样，通过创建多个循环对象，一个程序可以在同一个employee对象的jobs数组上执行多个循环。列表2的程序为我们展示了一个名字为jobiterator的循环类：
　　listing 2. jobiterator2.java
　　// jobiterator2.java
　　class job
　　{
　　private string jobtitle;
　　
　　job (string jobtitle)
　　{
　　this.jobtitle = jobtitle;
　　}
　　public string tostring ()
　　{
　　return jobtitle;
　　}
　　}
　　class employee
　　{
　　private string name;
　　private job [] jobs;
　　employee (string name, job [] jobs)
　　{
　　this.name = name;
　　this.jobs = jobs;
　　}
　　string getname ()
　　{
　　return name;
　　}
　　jobiterator getjobiterator ()
　　{
　　return new jobiterator (jobs);
　　}
　　}
　　class jobiterator
　　{
　　private job [] jobs;
　　private int jobindex = 0;
　　jobiterator (job [] jobs)
　　{
　　this.jobs = jobs;
　　}
　　boolean hasmorejobs ()
　　{
　　return jobindex < jobs.length;
　　}
　　job nextjob ()
　　{
　　return !hasmorejobs () ? null : jobs [jobindex++];
　　}
　　}
　　class jobiterator2
　　{
　　public static void main (string [] args)
　　{
　　job [] jobs = { new job ("janitor"), new job ("delivery person") };
　　employee e = new employee ("john doe", jobs);
　　system.out.println (e.getname () + " works the following jobs:/n");
　　jobiterator ji = e.getjobiterator ();
　　while (ji.hasmorejobs ())
　　system.out.println (ji.nextjob ());
　　}
　　}
　　jobiterator2的输出和jobiterator1一样，但有所不同的是，jobiterator2将循环的代码由employee转移到jobiterator。还有，employee声明了一个getjobiterator()的方法，可返回一个新的jobiterator对象引用。要注意到jobiterator和 employee是紧耦合的类：jobiterator的构造器需要一个employee私有jobs数组的引用。我们要记下这个耦合关系，因为它为理解类嵌套内部的工作提供了一个线索。
　　虽然jobiterator2很方便地解决了jobiterator1的问题，但这个新的程序又引入了一个新问题：由于新加入了一个和employee类处在同一级的jobiterator类，这样将来就不能在同一级的源文件中加入一个普遍的jobiterator接口。因为在源文件的同一级中，你不同拥有同样名字的两个类/接口。虽然在我们的例子中这不是一个严重的问题，但是在重要的程序中，有些情况下必须在同一个源文件中使用相同名字的类/接口。要令那些名字共存，你必须认识到一些类完全依赖其它的类。你应该在其依赖的类中声明这些类。列表3展示了如何在一个employee类中声明一个jobiterator类--jobiterator依赖employee类。
　　listing 3. jobiterator3.java
　　
　　// jobiterator3.java
　　
　　class job
　　{
　　private string jobtitle;
　　
　　job (string jobtitle)
　　{
　　this.jobtitle = jobtitle;
　　}
　　
　　public string tostring ()
　　{
　　return jobtitle;
　　}
　　}
　　
　　class employee
　　{
　　private string name;
　　private job [] jobs;
　　
　　employee (string name, job [] jobs)
　　{
　　this.name = name;
　　this.jobs = jobs;
　　}
　　
　　string getname ()
　　{
　　return name;
　　}
　　
　　jobiterator getjobiterator ()
　　{
　　return new jobiterator ();
　　}
　　
　　class jobiterator
　　{
　　private int jobindex = 0;
　　
　　public boolean hasmorejobs ()
　　{
　　return jobindex < jobs.length;
　　}
　　
　　public object nextjob ()
　　{
　　return !hasmorejobs () ? null : jobs [jobindex++];
　　}
　　}
　　}
　　class jobiterator3
　　{
　　public static void main (string [] args)
　　{
　　job [] jobs = { new job ("janitor"), new job ("delivery person") };
　　employee e = new employee ("john doe", jobs);
　　system.out.println (e.getname () + " works the following jobs:/n");
　　employee.jobiterator eji = e.getjobiterator ();
　　while (eji.hasmorejobs ())
　　system.out.println (eji.nextjob ());
　　}
　　}
　　jobiterator3的输出和jobiterator1、jobiterator2的一样，它使用了类嵌套：employee