当前位置：首页 > news >正文

Java 内部类

news 来源：原创 2025/5/25 2:44:39

Java 内部类

在 Java 中，内部类是一个强大的特性，它允许我们将一个类定义在另一个类或方法中。内部类不仅增强了代码的封装性，还为某些特定的编程场景提供了灵活的解决方案。本文将详细介绍内部类的概念、分类、使用方法以及实际应用场景。

1. 内部类的概念

内部类是指定义在另一个类或方法中的类。包含内部类的类称为外部类。内部类可以访问外部类的成员（包括私有成员），并且提供了更好的封装性和代码组织方式。

示例：

// 外部类 Car
public class Car {
    // 内部类 Engine
    class Engine {
        private void run() {
            System.out.println("发动机启动了！");
        }
    }
}

在上面的代码中，Engine 是内部类，Car 是外部类。

2. 内部类的分类

Java 中的内部类可以分为以下四种：

成员内部类
静态内部类
方法内部类（局部内部类）
匿名内部类

接下来我们将逐一介绍每种内部类的定义、特点和使用方法。

2.1 成员内部类

2.1.1 定义

成员内部类是最常见的内部类，它定义在外部类的成员位置，可以访问外部类的所有成员（包括私有成员）。

示例：

public class Car {
    private String name = "xiaomi";

    // 成员内部类
    class Engine {
        void run() {
            System.out.println(name + "启动！");
        }
    }
}

2.1.2 实例化

成员内部类不能直接实例化，必须通过外部类的实例来创建内部类的对象。

实例化方式：

public static void main(String[] args) {
    // 1. 先创建外部类实例
    Car car = new Car();
    // 2. 通过外部类实例创建内部类实例
    Car.Engine engine = car.new Engine();
    // 3. 调用内部类方法
    engine.run();
}

2.1.3 成员访问

内部类可以直接访问外部类的成员。
如果内部类和外部类有同名成员，可以通过 外部类名.this.成员 的方式访问外部类的成员。

示例：

class Car {
    String name = "外部类";

    class Engine {
        String name = "内部类";
        void print() {
            System.out.println(name);          // 访问内部类成员
            System.out.println(Car.this.name); // 访问外部类成员
        }
    }
}

2.2 静态内部类

2.2.1 定义

静态内部类使用 static 关键字修饰，它不能直接访问外部类的非静态成员，但可以访问外部类的静态成员。

示例：

public class Car {
    static String name = "外部类静态成员";

    // 静态内部类
    static class Engine {
        void run() {
            System.out.println(name); // 只能访问外部类的静态成员
        }
    }
}

2.2.2 实例化

静态内部类可以直接实例化，无需依赖外部类的实例。

实例化方式：

public static void main(String[] args) {
    Car.Engine engine = new Car.Engine();
    engine.run();
}

2.3 方法内部类（局部内部类）

2.3.1 定义

方法内部类定义在外部类的方法中，它的作用域仅限于该方法内部。

示例：

public class Car {
    void run() {
        // 方法内部类
        class Engine {
            void start() {
                System.out.println("发动机启动了！");
            }
        }
        // 在方法内部实例化并调用
        Engine engine = new Engine();
        engine.start();
    }
}

2.3.2 特点

方法内部类只能在定义它的方法中使用。
不能使用访问修饰符（如 public、private）。
不能定义静态成员。

2.4 匿名内部类

2.4.1 定义

匿名内部类是没有名字的内部类，通常用于实现接口或继承抽象类。它的定义和实例化同时完成。

示例：

public abstract class Transport {
    abstract void run();

    public static void main(String[] args) {
        // 匿名内部类
        Transport car = new Transport() {
            @Override
            void run() {
                System.out.println("汽车跑");
            }
        };
        car.run();
    }
}

2.4.2 特点

匿名内部类没有类名，无法编写构造方法。
通常用于简化代码，尤其是在只需要使用一次的类时。

3. 内部类的作用

3.1 增强封装性

内部类可以访问外部类的私有成员，同时将内部类的实现细节隐藏起来，增强了代码的封装性。

3.2 实现多重继承

Java 不支持多继承，但通过内部类可以实现类似的效果。例如，一个类可以通过多个内部类分别继承不同的类。

示例：

class SuperClass1 {
    void method1() {
        System.out.println("SuperClass1");
    }
}

class SuperClass2 {
    void method2() {
        System.out.println("SuperClass2");
    }
}

class SubClass {
    class InnerClass1 extends SuperClass1 {}
    class InnerClass2 extends SuperClass2 {}

    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.new InnerClass1().method1();
        sub.new InnerClass2().method2();
    }
}