Nested Classes（嵌套类） - Java™ Tutorials 翻译-优快云博客

本文详细介绍了Java编程语言中的嵌套类概念，包括静态嵌套类和非静态嵌套类的区别，以及它们如何与外部类交互。探讨了使用嵌套类的优点，如逻辑分组、增加封装性和提高代码可读性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、原文地址：

https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

二、原文翻译：

1、嵌套类

java编程语言允许在另一个类内部定义一个类。这样的类被叫做嵌套类，这里举例说明：

/** 外部类 **/
public class OuterClass {
    
    /** 嵌套类 **/
    public class NestedClass{
        
        
    }
}

术语：嵌套类分为两类：静态和非静态。被声明static的嵌套类被叫做静态嵌套类。非静态嵌套类被叫做内部类。

/**
 * 外部类
 * */
public class OuterClass {
    
    /**
     * 静态嵌套类
     */
    static class StaticNestedClass{
        
        
    }
    
    
    /**
     * 内部类
     */
    class InnerClass {
        
    }
}

嵌套类是它的封闭类(外部类)的成员。非静态嵌套类（内部类）可以访问封闭类的其他成员，即使他们（封闭类其他成员）被声明为private。静态嵌套类不可以访问封闭类的其他成员。作为OuterClass（上面代码块中的OuterClass类）的成员，嵌套类可以被声明为private, public, protected, or package private(包私有，不用任何修饰符修饰类，默认包私有)。回想下，外部类只能被声明为public或者package private（不用任何修饰符修饰，类默认包私有）。

2、为什么使用嵌套类？

使用嵌套类令人信服的原因包括以下：

这是对只在一个地方使用的类进行逻辑分组的方式：如果一个类仅仅对其他一个类有用，将它嵌入到那个类中并保持在一起是符合逻辑的。嵌入这样的“助手类”让它们的包更简化。

增加了封装：想下两个顶级类， A和B，B需要访问A中被声明为private的成员。通过将类B隐藏在类A中，A的成员可以被声明为private并且B能够访问它们。另外，B本身对外面的世界隐藏了。

可以生成更可读和更易维护的代码。将小的类嵌套到顶级类中，让它离被使用的位置更近。

3、静态嵌套类

和类方法和变量一样，静态嵌套类与它的外部类相关联。就像静态类方法，静态嵌套类不能直接引用在它的封闭类（外部类）中定义的实例变量和方法。只能通过传递对象引用使用它们（封闭类的实例变量和方法）。

注意：静态嵌套类与它的外部类实例成员交互就和任何其他顶级类一样。实际上，静态嵌套类行为上是个顶级类，被嵌套到其他顶级类中以方便打包。

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

OuterClass.StaticNestedClass

例如，创建静态嵌套类的对象，使用这个语法：

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

4、内部类

和实例变量和方法一样，内部类与它的封闭类的实例相关联，可以直接访问那个对象（封闭类的实例）的方法和字段。还有，因为内部类与实例相关联，它本身不能定义任何静态成员。

内部类实例对象存在于外部类实例中。思考下下面的类：

/**
 * 外部类
 * */
public class OuterClass {
    
    
    /**
     * 内部类
     */
    class InnerClass {
        
    }
}

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

为了实例化内部类，你必须先实例化外部类。然后用这个语法在外部类对象中创建内部类对象：

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

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

5、遮蔽：

如果在特定范围（例如内部类或方法定义）的类型声明（例如成员变量或参数名称）和在封闭（外部）范围的声明名称相同，那么这个声明会遮蔽封闭（外部）范围的声明。你不能仅仅通过名称引用被遮蔽的声明。下面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. 定义为方法methodInFirstLevel参数的变量x遮蔽了内部类FirstLevel的变量（成员变量）。因此，当你在方法methodInFirstLevel中使用变量x，它指向方法参数。为了指向内部类FirstLevel的成员变量，使用关键字this代替封闭范围：

System.out.println("this.x = " + this.x);

指向属于用类名括起来的更大范围的成员变量。例如：下面的语句从方法methodInFirstLevel中访问类ShadowTest的成员变量：

System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

6、序列化

内部类的序列化，包括局部和匿名类，强烈不被建议。当编译器编译某些结构，例如内部类，它会创建一些合成结构，有在源码中没有相应结构的类、方法、字段和其他结构。合成结构允许java编译器实现新的java语言特性，而不用修改JVM。但是，合成结构在不同的java编译实现中会不同，这意味着.class文件在不同（java编译）实现中也不同。因此，如果你序列化了一个内部类，然后用不同的JRE实现反序列它，可能会有兼容问题。查看<$章节$>获取更多有关内部类被编译时创建合成结构的信息。

👉👉👉 自己搭建的租房网站：全网租房助手，m.kuairent.com，每天新增 500+房源