Java 内部类：分类、用法与核心场景

最新推荐文章于 2025-12-02 21:20:38 发布

原创最新推荐文章于 2025-12-02 21:20:38 发布 · 895 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java 进阶专栏收录该内容

12 篇文章

订阅专栏

Java 内部类（Inner Class）是定义在另一个类 / 接口内部的类，核心价值是封装性、代码复用，还能直接访问外部类的成员（包括私有）。根据定义方式和特性，内部类分为 4 种核心类型，下面逐一拆解：

一、内部类的核心共性

依赖外部类：非静态内部类必须通过外部类实例才能创建，不能直接实例化；
访问权限：可访问外部类的所有成员（public/private/protected），外部类访问内部类需通过内部类实例；
编译产物：内部类编译后生成独立.class 文件，命名规则为「外部类名内部类名」（如Inner.class`）。

二、4 种内部类的详细解析

1. 成员内部类（非静态内部类）

最常用的内部类，定义在外部类的成员位置（与属性、方法同级），无 static 修饰。

核心特性

依赖外部类实例：必须先创建外部类对象，才能通过「外部类对象.new 内部类 ()」创建内部类实例；
可访问外部类：直接访问外部类的所有成员（包括 private），若与外部类成员同名，用「外部类名.this. 成员」区分。

示例代码

class Outer {
    private String outerName = "外部类";

    // 成员内部类
    class Inner {
        private String innerName = "内部类";
        
        public void show() {
            // 访问外部类成员
            System.out.println(outerName); 
            // 同名时区分：外部类名.this.成员
            System.out.println(Outer.this.outerName); 
            System.out.println(innerName);
        }
    }
}

// 调用方式
public class Test {
    public static void main(String[] args) {
        // 1. 创建外部类实例
        Outer outer = new Outer();
        // 2. 通过外部类实例创建内部类实例
        Outer.Inner inner = outer.new Inner();
        inner.show(); // 输出：外部类、外部类、内部类
    }
}

使用场景

与外部类强关联：内部类的逻辑仅服务于外部类，且需要频繁访问外部类成员（如外部类的辅助工具类）；
封装细节：将内部类设为 private，仅外部类可访问，隐藏实现细节。

2. 静态内部类（嵌套类）

定义在外部类成员位置，有 static 修饰，本质是 “嵌套在外部类中的独立类”。

核心特性

不依赖外部类：可直接通过「外部类名。内部类名」创建实例，无需外部类对象；
访问限制：仅能访问外部类的静态成员（static 属性 / 方法），不能访问非静态成员；
独立存在：编译后是独立.class 文件，与外部类的生命周期无关。

示例代码

class Outer {
    private static String staticName = "外部静态成员";
    private String nonStaticName = "外部非静态成员";

    // 静态内部类
    static class StaticInner {
        public void show() {
            System.out.println(staticName); // 可访问外部静态成员
            // System.out.println(nonStaticName); // 编译报错：不能访问非静态成员
        }
    }
}

// 调用方式
public class Test {
    public static void main(String[] args) {
        // 直接创建静态内部类实例（无需外部类对象）
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.show(); // 输出：外部静态成员
    }
}

使用场景

与外部类弱关联：内部类逻辑相对独立，仅需使用外部类的静态资源（如工具类、常量容器）；
避免外部类膨胀：将与外部类相关但独立的逻辑封装为静态内部类（如 Java 集合框架中的HashMap.Node）。

3. 局部内部类

定义在方法 / 代码块内部的类，作用域仅限于当前方法 / 代码块。

核心特性

作用域限制：仅在定义它的方法 / 代码块内可见，外部无法访问；
访问限制：可访问外部类成员，若要访问方法内的局部变量，该变量必须是「final 或 effectively final」（Java 8 + 默认 effectively final，即变量赋值后不修改）；
无访问修饰符：不能用 public/private/static 等修饰。

示例代码

class Outer {
    private String outerName = "外部类";

    public void outerMethod() {
        final String localVar = "方法局部变量"; // effectively final（赋值后不修改）

        // 局部内部类（定义在方法内）
        class LocalInner {
            public void show() {
                System.out.println(outerName); // 访问外部类成员
                System.out.println(localVar); // 访问方法局部变量（必须final/effectively final）
            }
        }

        // 仅在当前方法内创建并使用
        LocalInner inner = new LocalInner();
        inner.show();
    }
}

// 调用方式
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod(); // 输出：外部类、方法局部变量
    }
}

使用场景

方法内临时复用逻辑：某个方法的逻辑复杂，需要拆分出独立类，但该类仅在当前方法内使用（如排序算法中的比较器、临时数据封装类）；
避免污染命名空间：局部内部类仅作用于方法内，不会与外部类的其他成员冲突。

4. 匿名内部类（重点）

没有类名的局部内部类，一次性使用（仅创建一个实例），是 Java 8 前实现函数式接口的核心方式。

核心特性

无类名：通过「new 父类 / 接口 () { 实现逻辑}」直接创建实例；
一次性：仅能创建一个实例，不能重复使用；
继承 / 实现：必须继承一个父类或实现一个接口（通常是函数式接口，即仅一个抽象方法的接口）；
访问限制：同局部内部类，可访问外部类成员，访问局部变量需是 final/effectively final。

示例代码（实现接口）

// 函数式接口（仅一个抽象方法）
interface Greet {
    void sayHello();
}

class Outer {
    public void showGreet() {
        // 匿名内部类：实现Greet接口，直接创建实例
        Greet greet = new Greet() {
            @Override
            public void sayHello() {
                System.out.println("匿名内部类实现接口");
            }
        };
        greet.sayHello();
    }
}

// 简化：Java 8+ Lambda表达式（替代匿名内部类）
// Greet greet = () -> System.out.println("Lambda替代匿名内部类");

示例代码（继承父类）

class Animal {
    public void cry() {
        System.out.println("动物叫");
    }
}

public class Test {
    public static void main(String[] args) {
        // 匿名内部类：继承Animal类，重写方法
        Animal dog = new Animal() {
            @Override
            public void cry() {
                System.out.println("小狗汪汪叫");
            }
        };
        dog.cry(); // 输出：小狗汪汪叫
    }
}