Java™ 教程（嵌套类）

Java编程语言允许你在另一个类中定义类，这样的类称为嵌套类，如下所示：

</>复制代码 
class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

</>复制代码 
术语：嵌套类分为两类：静态和非静态，声明为static的嵌套类称为静态嵌套类，非静态嵌套类称为内部类。

</>复制代码 
class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

嵌套类是其封闭类的成员，非静态嵌套类（内部类）可以访问封闭类的其他成员，即使它们被声明为private，静态嵌套类无权访问封闭类的其他成员。作为OuterClass的成员，可以将嵌套类声明为private、public、protected或包私有（回想一下，外部类只能声明为public或包私有）。

使用嵌套类的令人信服的理由包括：

这是一种逻辑分组仅在一个地方使用的类的方法：如果一个类只对另一个类有用，那么将它嵌入该类并将两者保持在一起是合乎逻辑的，嵌套这样的“帮助类”使得它们的包更加简化。

它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为private，通过将类B隐藏在类A中，可以将A的成员声明为私有，并且B可以访问它们，另外，B本身也可以不被外界发现。

它可以使代码更具可读性和可维护性：在顶级类中嵌套小类会使代码更接近于使用它的位置。

与类方法和变量一样，静态嵌套类与其外部类相关联，和静态类方法一样，静态嵌套类不能直接引用其封闭类中定义的实例变量或方法：它只能通过对象引用来使用它们。

</>复制代码 
注意：静态嵌套类与其外部类（和其他类）的实例成员交互，就像任何其他顶级类一样，实际上，静态嵌套类在行为上是一个顶级类，它已嵌套在另一个顶级类中以方便打包。

使用封闭的类名访问静态嵌套类：

</>复制代码 
OuterClass.StaticNestedClass

例如，要为静态嵌套类创建对象，请使用以下语法：

</>复制代码 
OuterClass.StaticNestedClass nestedObject =
     new OuterClass.StaticNestedClass();

与实例方法和变量一样，内部类与其封闭类的实例相关联，并且可以直接访问该对象的方法和字段，此外，由于内部类与实例相关联，因此本身无法定义任何静态成员。

作为内部类的实例的对象存在于外部类的实例中，考虑以下类：

</>复制代码 
class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

InnerClass的实例只能存在于OuterClass的实例中，并且可以直接访问其封闭实例的方法和字段。

要实例化内部类，必须首先实例化外部类，然后，使用以下语法在外部对象中创建内部对象：

</>复制代码 
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

有两种特殊的内部类：局部类和匿名类。

如果特定范围（例如内部类或方法定义）中的类型声明（例如成员变量或参数名称）与封闭范围中的另一个声明具有相同的名称，然后声明会影响封闭范围的声明，你不能仅通过其名称引用遮蔽的声明，以下示例ShadowTest演示了这一点：

</>复制代码 
public class ShadowTest {
    public int x = 0;
    class FirstLevel {
        public int x = 1;
        void methodInFirstLevel(int x) {
            System.out.println("x = " + x);
            System.out.println("this.x = " + this.x);
            System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
        }
    }
    public static void main(String... args) {
        ShadowTest st = new ShadowTest();
        ShadowTest.FirstLevel fl = st.new FirstLevel();
        fl.methodInFirstLevel(23);
    }
}

以下是此示例的输出：

</>复制代码 
x = 23
this.x = 1
ShadowTest.this.x = 0

此示例定义了三个名为x的变量：ShadowTest类的成员变量、内部类FirstLevel的成员变量、以及方法methodInFirstLevel中的参数。变量x定义为方法methodInFirstLevel的参数遮蔽内部类FirstLevel的变量，因此，当你在方法methodInFirstLevel中使用变量x时，它引用方法参数，要引用内部类FirstLevel的成员变量，请使用关键字this来表示封闭范围：

</>复制代码 
System.out.println("this.x = " + this.x);

引用成员变量，这些成员变量根据所属的类名包含更大的作用域，例如，以下语句从方法methodInFirstLevel访问类ShadowTest的成员变量：

</>复制代码 
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

强烈建议不要对内部类（包括局部类和匿名类）进行序列化，当Java编译器编译某些构造（如内部类）时，它会创建合成构造，这些是类、方法、字段和其他在源代码中没有相应构造的构造。合成构造使Java编译器能够在不更改JVM的情况下实现new的Java语言功能，但是，合成构造可以在不同的Java编译器实现之间变化，这意味着.class文件也可以在不同的实现之间变化。因此，如果序列化内部类，然后使用其他JRE实现反序列化，则可能存在兼容性问题，有关在编译内部类时生成的合成构造的更多信息，请参阅获取方法参数名称一节中的隐式和合成参数部分。

要看内部类的使用，首先要考虑一个数组，在下面的示例中，你将创建一个数组，用整数值填充它，然后仅按升序输出数组的偶数索引值。

下面的DataStructure.java示例包括：

DataStructure外部类，它包含一个构造函数，用于创建DataStructure的实例，该实例包含一个数组，该数组填充了连续的整数值（0、1、2、3等等），以及一个方法，该方法打印具有偶数索引值的数组元素。

EvenIterator内部类，它实现了继承了Iterator< Integer>接口的DataStructureIterator接口，迭代器用于逐步执行数据结构，通常有方法来测试最后一个元素，检索当前元素，然后移动到下一个元素。

实例化DataStructure对象（ds）的main方法，然后调用printEven方法来打印具有偶数索引值的数组arrayOfInts的元素。

</>复制代码 
public class DataStructure {
    
    // Create an array
    private final static int SIZE = 15;
    private int[] arrayOfInts = new int[SIZE];
    
    public DataStructure() {
        // fill the array with ascending integer values
        for (int i = 0; i < SIZE; i++) {
            arrayOfInts[i] = i;
        }
    }
    
    public void printEven() {
        
        // Print out values of even indices of the array
        DataStructureIterator iterator = this.new EvenIterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
    }
    
    interface DataStructureIterator extends java.util.Iterator { } 
    // Inner class implements the DataStructureIterator interface,
    // which extends the Iterator interface
    
    private class EvenIterator implements DataStructureIterator {
        
        // Start stepping through the array from the beginning
        private int nextIndex = 0;
        
        public boolean hasNext() {
            
            // Check if the current element is the last in the array
            return (nextIndex <= SIZE - 1);
        }        
        
        public Integer next() {
            
            // Record a value of an even index of the array
            Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);
            
            // Get the next even element
            nextIndex += 2;
            return retValue;
        }
    }
    
    public static void main(String s[]) {
        
        // Fill the array with integer values and print out only
        // values of even indices
        DataStructure ds = new DataStructure();
        ds.printEven();
    }
}

输出是：

</>复制代码 
0 2 4 6 8 10 12 14

请注意，EvenIterator类直接引用DataStructure对象的arrayOfInts实例变量。

你可以使用内部类来实现辅助类，例如本示例中所示的类，要处理用户界面事件，你必须知道如何使用内部类，因为事件处理机制会广泛使用它们。

还有两种类型的内部类，你可以在方法体内声明内部类，这些类称为局部类，你还可以在方法体内声明内部类，而无需命名该类，这些类称为匿名类。

你可以对用于外部类的其他成员的内部类使用相同的修饰符，例如，你可以使用访问修饰符private、public和protected来限制对内部类的访问，就像你使用它们来限制对其他类成员的访问一样。