Java支持哪些嵌套类？
Java将嵌套类分成两个主要的分类：嵌套顶级类（nested top-level classes）和内部类（inner classes）。Java还进一步将内部类分为实例内部类（instance inner class） ，本地内部类（local inner class）和匿名内部类（and anonymous inner class）。要掌握嵌套类，你需要懂得每个分类。以下我们就来讨论以下这些分类，首先我们来看一下嵌套顶级类。
嵌套顶级类
当你在其它类的外面声明一个类时，Java就认为该类是一个顶级类。如果你在一个顶级类中声明一个类，并且在该嵌套类的声明前加上static的修饰符，你就得到了一个嵌套顶级类。以下的代码段声明了一个顶级类和一个嵌套顶级类：
class TopLevelClass
{
static class NestedTopLevelClass
{
}
}
就象静态的字段和静态的方法一样（也可称为类字段和类方法），一个嵌套的顶级类也是与对象无关的。考虑以下的代码段：
class TopLevelClass
{
static int staticField;
int instanceField;
static class NestedTopLevelClass
{
static
{
System.out.println ("Can access staticField " + staticField);
// System.out.println ("Cannot access instanceField " + instanceField);
}
{
System.out.println ("Can access staticField " + staticField);
// System.out.println ("Cannot access instanceField " + instanceField);
}
}
}
在上面NestedTopLevelClass类的类初始化和对象初始化代码块中，你可以访问TopLevelClass的staticField变量。不过你在这两个代码块中都不能访问instanceField变量。因为NestedTopLevelClass和任何的TopLevelClass对象都是无关的，所以NestedTopLevelClass 不能访问TopLevelClass的instanceField变量。
警告：一个嵌套顶级类不能访问任何外部类的实例成员（包括字段和方法）。
虽然NestedTopLevelClass不能访问TopLevelClass的实例字段，但是static的修饰符并不会妨碍NestedTopLevelClass声明自己的实例字段，以及创建NestedTopLevelClass对象。列表4的代码就是一个很好的例子：
Listing 4. NestedTopLevelClassDemo.java
// NestedTopLevelClassDemo.java
class TopLevelClass
{
static class NestedTopLevelClass
{
int myInstanceField;
NestedTopLevelClass (int i)
{
myInstanceField = i;
}
}
}
class NestedTopLevelClassDemo
{
public static void main (String [] args)
{
TopLevelClass.NestedTopLevelClass ntlc;
ntlc = new TopLevelClass.NestedTopLevelClass (5);
System.out.println (ntlc.myInstanceField);
}
}
在运行后，NestedTopLevelClassDemo产生以下的输出：
5
NestedTopLevelClassDemo的main()方法创建了一个NestedTopLevelClass变量--ntlc。声明该变量的语法和列表3的一样（Employee.JobIterator eji = e.getJobIterator ()）。 通常，当你需要一个嵌套类的变量时，要在该嵌套类名的前面加入所有外部类的名字，并且用“.”将它们分开。用new关键字声明该嵌套类的时候也要这样做。
这时，你可能想知道你是否可以在一个嵌套顶级类中声明一个顶级嵌套类。还有，如果两个不同的外部类声明了同样的字段变量名，但该变量的类型或者初始化值是不同的？要解答这些问题，可看列表5：
Listing 5. NestingAndShadowingDemo.java
// NestingAndShadowingDemo.java
class TopLevelClass
{
private static int a = 1;
private static int b = 3;
static class NestedTopLevelClass
{
private static int a = 2;
static class NestedNestedTopLevelClass
{
void printFields ()
{
System.out.println ("a = " + a);
System.out.println ("b = " + b);
}
}
}
}
class NestingAndShadowingDemo
{
public static void main (String [] args)
{
TopLevelClass.NestedTopLevelClass.NestedNestedTopLevelClass nntlc;
nntlc = new TopLevelClass.NestedTopLevelClass.
NestedNestedTopLevelClass ();
nntlc.printFields ();
}
}
在运行时，NestingAndShadowingDemo产生以下的输出：
a = 2
b = 3
NestingAndShadowingDemo可以编译运行证明你可以在顶级嵌套类中嵌套顶级嵌套类。结果也显示了NestedTopLevelClass的一个字段屏蔽了TopLevelClass的字段。结果是打印出NestedTopLevelClass的字段内容。
使用嵌套顶级类，你不可以访问外部类的实例字段或者调用该类的实例方法。要访问实例成员，Java支持内部类。内部类和嵌套顶级类相似，不同的地方是你不会在内部内的声明前加上static关键字。我们以下就讨论一下内部类，先从实例内部类开始。
提示：你可以在顶级嵌套类前加上private，protected或者public关键字，以指示该类在外部类以外的访问级别。
实例内部类（Instance inner classes）
假设你在声明嵌套类时，没有在前面加上static关键字。这样你得到的不是一个嵌套顶级类，你得到的是一个实例内部类。嵌套顶级类只可以访问外部内的static成员，而实例内部类可以同时访问static和实例成员。列表3的代码中有实例内部内的例子。在Employee类中，你可以看到实例内部类JobIterator。仔细观察这两个类，你可以看到JobIterator可以访问Employee的private jobs实例字段。
提示：你可以在实例内部类前加上private，protected或者public关键字，以指示该类在外部类以外的访问级别。
本地内部类（Local inner classes）
除了以上的类嵌套外，Java还允许你在任意的代码段中放入一个类，该类的代码放在一对大括号中（{ }）。这意味着类可以出现在一个方法中，甚至是在if语句的一对括号中。这样的类就称为本地内部类。
相对于实例内部类来说，本地内部类与有一个好处。它除了可以访问外部类的实例和类字段外（称为实例和类方法），还可以访问本地变量和方法的参数。列表６就是一个本地内部类：
Listing 6. LocalInnerClassDemo.java
// LocalInnerClassDemo.java
import java.util.*;
class ComputerLanguage
{
private String name;
ComputerLanguage (String name)
{
this.name = name;
}
public String toString ()
{
return name;
}
}
class LocalInnerClassDemo
{
public static void main (String [] args)
{
ComputerLanguage [] cl =
{
new ComputerLanguage ("Ada"),
new ComputerLanguage ("Algol"),
new ComputerLanguage ("APL"),
new ComputerLanguage ("Assembly - IBM 360"),
new ComputerLanguage ("Assembly - Intel"),
new ComputerLanguage ("Assembly - Mostek"),
new ComputerLanguage ("Assembly - Motorola"),
new ComputerLanguage ("Assembly - VAX"),
new ComputerLanguage ("Assembly - Zilog"),
new ComputerLanguage ("BASIC"),
new ComputerLanguage ("C"),
new ComputerLanguage ("C++"),
new ComputerLanguage ("Cobol"),
new ComputerLanguage ("Forth"),
new ComputerLanguage ("Fortran"),
new ComputerLanguage ("Java"),
new ComputerLanguage ("LISP"),
new ComputerLanguage ("Logo"),
new ComputerLanguage ("Modula 2"),
new ComputerLanguage ("Pascal"),
new ComputerLanguage ("Perl"),
new ComputerLanguage ("Prolog"),
new ComputerLanguage ("Snobol")
};
Enumeration e = enumerator ((Object []) cl);
while (e.hasMoreElements ())
System.out.println (e.nextElement ());
}
static Enumeration enumerator (final Object [] array)
{
class LocalInnerClass implements Enumeration
{
private int index = 0;
public boolean hasMoreElements ()
{
return index < array.length;
}
public Object nextElement ()
{
return array [index++].toString ();
}
}
return new LocalInnerClass ();
}
}
在运行后, LocalInnerClassDemo产生以下的输出：
Ada
Algol
APL
Assembly - IBM 360
Assembly - Intel
Assembly - Mostek
Assembly - Motorola
Assembly - VAX
Assembly - Zilog
BASIC
C
C++
Cobol
Forth
Fortran
Java
LISP
Logo
Modula 2
Pascal
Perl
Prolog
Snobol
LocalInnerClassDemo展示了在LocalInnerClassDemo的enumerator()类方法中声
