内部类

内部类概述

什么是内部类？

内部类是定义在另一个类内部的类，可以定义在外部类的成员位置或局部位置。

作用：把紧密相关的类组合在一起，提高封装性和可读性。

什么时候使用内部类？

当一个类内部还包含另一个类时，可以使用内部类来表示内部事物。例如，在描述汽车时，汽车包含 发动机，发动机可以用内部类来描述：

class Car {
    private String brand;
 
    Car(String brand) {
        this.brand = brand;
    }
 
    // 成员内部类
    class Engine {
        void start() {
            System.out.println(brand + " engine started");
        }
    }
}
 

内部类的分类

1. 成员内部类（Member Inner Class）：定义在类成员位置，依赖外部类实例。
2. 静态内部类（Static Nested Class）：使用 static 修饰，不依赖外部类实例。
3. 局部内部类（Local Inner Class）：定义在方法或作用域内，只能在该方法内使用。
4. 匿名内部类（Anonymous Inner Class）：没有类名，通常用于临时实现接口或继承类。

成员内部类

成员内部类定义在外部类成员位置，可通过外部类对象访问：

public class Main {
    public static void main(String[] args) {
        OuterClass.InnerClass in = new OuterClass()
          .new InnerClass("内部类成员");
      
        in.show("局部变量");
    }
}
 
class OuterClass {
    String name = "外部类成员";
 
    class InnerClass {
        String name;
 
        public InnerClass() {}
 
        public InnerClass(String name) {
            this.name = name;
        }
 
        public void show(String name) {
            System.out.println("局部变量：" + name);
            System.out.println("成员内部类成员变量：" + this.name);
            System.out.println("外部类成员变量：" + OuterClass.this.name);
        }
    }
}
 

---

💡注意

1. 外部类的静态方法不能直接访问成员内部类。
2. 成员内部类不能定义静态变量和方法（JDK16 后允许定义静态常量）。
3. 成员内部类依附于外部类，必须先创建外部类对象才能创建内部类对象。
4. 访问外部类成员：外部类.this.成员变量 / 外部类.this.成员方法。

静态内部类

静态内部类使用 static 修饰，不依赖外部类实例：

class OuterClass {
    public static class InnerClass {
        String name;
 
        public InnerClass() {}
 
        public InnerClass(String name) {
            this.name = name;
        }
 
        public void show() {
            System.out.println("静态内部类的show方法");
        }
    }
}
 
public class Main {
    public static void main(String[] args) {
        OuterClass.InnerClass inner = new OuterClass.InnerClass("小明");
        System.out.println("name: " + inner.name);
        inner.show();
    }
}
 

---

💡注意

1. 静态内部类不依赖外部类实例。
2. 静态内部类不能访问外部类的非静态成员。
3. 内部类定义静态成员时，该内部类必须是静态的。
4. 调用静态成员：OuterClass.InnerClass.staticVariable / OuterClass.InnerClass.staticFunction()。

局部内部类

局部内部类定义在外部类方法中，只能在方法内实例化：

class OuterClass {
    String name = "外部类成员";
 
    public void test() {
        final int num = 18; // JDK1.8后可省略final
        class InnerClass {
            String name;
 
            public InnerClass() {}
            public InnerClass(String name) { this.name = name; }
 
            public void show(String name) {
                System.out.println("局部变量：" + name);
                System.out.println("成员内部类成员变量：" + this.name);
                System.out.println("外部类成员变量：" + OuterClass.this.name);
                System.out.println("外部局部变量：" + num);
            }
        }
 
        InnerClass in = new InnerClass("内部类成员");
        in.show("局部变量");
    }
}
 
public class Main {
    public static void main(String[] args) {
        new OuterClass().test();
    }
}
 

---

💡注意

1. 局部内部类只能在方法内实例化。
2. 不能定义静态变量和方法。
3. 依附于外部类，必须先创建外部类对象。
4. 访问外部类成员：外部类.this.成员变量/方法。
5. 访问方法局部变量需使用 final 或 JDK1.8+ 可省略。

匿名内部类

匿名内部类没有类名，是局部内部类的一种快捷写法：

abstract class Parent {
    abstract void show1();
    abstract void show2();
}
 
class Main {
    public void test() {
        Parent p = new Parent() {
            @Override
            void show1() {
                System.out.println("匿名内部类show1");
            }
 
            @Override
            void show2() {
                System.out.println("匿名内部类show2");
            }
        };
 
        p.show1();
        p.show2();
    }
 
    public static void main(String[] args) {
        new Main().test();
    }
}
 

---

💡注意

1. 匿名内部类继承了局部内部类的所有限制。
2. 不能定义构造函数，可用构造代码块初始化。
3. 不建议添加复杂的成员变量和方法，使用不便。