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+房源

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值