Java 中的内部类

在 Java 中，类是可以嵌套的（即一个类可以包含另一个类）。嵌套类的目的是将相关的类组织在一起，这样可以使代码更加简洁、可读和易于维护。

要访问内部类，可以先创建外部类的对象，然后再创建内部类的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class OuterClass {
  int x = 10; // 外部类中的实例变量 x

  class InnerClass {
    int y = 5; // 内部类中的实例变量 y
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass(); // 创建外部类的实例 myOuter
    OuterClass.InnerClass myInner = myOuter.new InnerClass(); // 创建内部类的实例 myInner
    System.out.println(myInner.y + myOuter.x); // 输出内部类 y 和外部类 x 的和
  }
}

在 main 方法中：

  • OuterClass myOuter = new OuterClass(); 这行代码创建了外部类 OuterClass 的一个实例 myOuter。
  • OuterClass.InnerClass myInner = myOuter.new InnerClass(); 这行代码通过外部类实例 myOuter 创建了内部类 InnerClass 的一个实例 myInner。请注意，内部类的实例必须通过外部类的实例来创建，因为内部类通常访问外部类的成员。
  • System.out.println(myInner.y + myOuter.x); 这行代码计算并打印 myInner 中的变量 y 和 myOuter 中的变量 x 的和。myInner.y 的值是 5，myOuter.x 的值是 10，因此输出结果是 15。

Private 内部类：

​ 如果不希望外部类或其他类访问你的内部类，可以将其声明为 private，这样只有外部类中的方法和成员能够访问它。外部类的其他部分以及其他类将无法直接创建或访问这个内部类。

如果尝试从外部类访问私有内部类，则会发生错误，例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

输出将会报错：

1
2
java: 类 Main 是公共的, 应在名为 Main.java 的文件中声明
java: OuterClass.InnerClass 在 OuterClass 中是 private 访问控制

Static内部类

​ 如果内部类被声明为 static，则它就不再依赖于外部类的实例。换句话说，你可以直接通过外部类的类名来访问静态内部类，而不需要先创建外部类的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}// 输出结果：5

1. 注意：就像属性和方法一样，内部类无法访问外部类的成员（非静态成员）。

  • 非静态内部类：需要依赖外部类的实例，因此可以访问外部类的实例成员。
  • 静态内部类：不依赖于外部类的实例，而是属于外部类的类级别的成员。它只能访问外部类的 静态成员，不能访问外部类的实例成员。

2. 访问外部类的成员从内部类：

内部类的一个优点是，它们可以访问外部类的属性和方法。

解释：

  • 外部类的实例成员（即非静态成员）可以被 非静态内部类 访问，因为非静态内部类是与外部类的实例相关联的。非静态内部类需要依赖实例

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class OuterClass {
  int x = 10;  // 外部类的成员变量 x，初始化为 10

  // 定义一个内部类 InnerClass
  class InnerClass {
    public int myInnerMethod() {
      return x;  // 内部类的方法，返回外部类成员变量 x 的值
    }
  }
}
public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();  // 创建外部类 OuterClass 的实例 myOuter
    OuterClass.InnerClass myInner = myOuter.new InnerClass();  // 通过外部类实例 myOuter 创建内部类 InnerClass 的实例 myInner
    System.out.println(myInner.myInnerMethod());  // 调用内部类的方法 myInnerMethod，输出返回值
  }
}

public int myInnerMethod() 方法

是 InnerClass 的一个成员方法，它返回外部类实例变量 x 的值。由于 InnerClass 是外部类的内部类，它可以直接访问外部类的实例变量 x。

  • 非静态内部类 可以访问外部类的所有实例成员（包括变量和方法）。
  • 创建内部类的实例时，必须通过外部类的实例来创建。