JavaSE : 内部类

Java中的内部类是一个重要的特性，允许在一个类的定义内部定义另一个类。内部类分为几种不同类型，每种都有其特定的用途和访问权限特点。以下是关于Java内部类的知识大纲：

1. 内部类的基本概念

定义与分类

内部类（Inner Class）是定义在另一个类（称为外部类或包围类）内部的类。根据定义的位置和用途，内部类可以分为以下几种类型：

• 成员内部类（Member Inner Class）：定义在外部类的成员位置上，可以有访问修饰符，可以访问外部类的所有成员，包括私有成员。
• 静态嵌套类（Static Nested Class）：与成员内部类相似，但使用 static 修饰，不依赖于外部类的实例，相当于外部类的一个静态成员。
• 局部内部类（Local Inner Class）：定义在外部类的方法或代码块中，其作用域仅限于该方法或代码块，不能使用访问修饰符。
• 匿名内部类（Anonymous Inner Class）：没有类名的局部内部类，常用于创建一次性使用的类实例，特别是在实现接口或继承类时。

访问权限

• 内部类访问外部类：内部类可以访问外部类的所有成员，无论它们的访问权限如何（包括私有成员），因为内部类被视为外部类的一部分。
• 外部类访问内部类：外部类想要访问内部类的成员，必须先创建内部类的实例。静态嵌套类可以通过外部类名直接访问，而非静态内部类需要通过外部类的实例来访问。

作用域与生命周期

• 成员内部类：作用域与外部类相同，但其生命周期依赖于外部类的实例。只有当外部类实例被创建时，内部类才能被实例化。
• 静态嵌套类：作用域也是整个外部类，但生命周期独立，不依赖于外部类的实例。
• 局部内部类：作用域局限于定义它的方法或代码块，生命周期与方法或代码块的执行周期一致，超出作用域则不可访问。
• 匿名内部类：作用域最窄，仅限于创建它的语句，生命周期随其创建实例的生命周期结束而结束，通常用于即时操作或事件处理。

2. 成员内部类

定义与实例化

• 定义：成员内部类是定义在外部类的成员位置上的一个类，可以位于字段、方法之前或之后，它就像一个成员变量一样属于外部类的一部分。成员内部类可以有访问修饰符（如private, protected, public, 默认），决定了其可见性。

  public class OuterClass {
      // 成员内部类的定义
      class MemberInnerClass {
          // 内部类的成员
      }
  }
  

• 实例化：创建成员内部类的对象需要通过外部类的实例来完成，因为成员内部类是依赖于外部类实例的。

  OuterClass outer = new OuterClass();
  OuterClass.MemberInnerClass inner = outer.new MemberInnerClass();
  

访问外部世界

• 外部类实例成员：成员内部类的实例可以访问创建它的外部类实例的成员，因为内部类持有对外部类实例的隐式引用。

  public class Outer {
      private int data = 10;
      
      class Inner {
          void displayData() {
              System.out.println(data); // 访问外部类的data
          }
      }
  }
  
  // 创建外部类和内部类的实例
  Outer outer = new Outer();
  Outer.Inner inner = outer.new Inner();
  inner.displayData(); // 输出: 10
  

总结来说，成员内部类提供了高度的封装性和代码组织性，允许内部类直接访问外部类的私有成员，同时通过外部类的实例来控制内部类的创建和访问外部世界。

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

特点

• 独立性：静态嵌套类（也称为静态内部类或嵌套静态类）是用 static 关键字修饰的内部类，它不依赖于外部类的实例，可以直接通过外部类名来访问和实例化，就像访问静态成员一样。
• 内存模型：静态嵌套类的实例在内存中有独立的空间，与外部类实例无关，其生命周期也不受外部类实例的影响。

使用场景

• 逻辑关联：当一个类与另一个类逻辑上紧密相关，但在功能上不依赖于外部类的实例时，适合使用静态嵌套类。
• 工具类或辅助类：可以用来封装一些辅助方法或工具方法，这些方法可能需要访问外部类的静态成员，但不需要外部类的实例。
• 单例模式：静态嵌套类常用于实现单例模式中的静态内部类形式，因为它可以保证线程安全且延迟加载。

访问权限

• 访问外部类成员：静态嵌套类不能直接访问外部类的非静态成员，因为静态成员独立于任何外部类的实例存在。若要访问外部类的非静态成员，必须通过外部类的实例来访问。
• 访问静态成员：静态嵌套类可以访问外部类的静态成员，包括静态字段和静态方法，因为静态成员属于类级别，与类的实例无关。

示例代码：

public class OuterClass {
    private static int staticVar = 10;
    private int instanceVar = 20;

    // 静态嵌套类
    public static class StaticNestedClass {
        public void accessMembers() {
            // 可以访问外部类的静态成员
            System.out.println("静态变量: " + staticVar);

            // 不能直接访问非静态成员，除非通过外部类实例
            // 下面的代码会报错
            // System.out.println("实例变量: " + instanceVar);

            // 通过外部类实例访问非静态成员的正确方式
            OuterClass outer = new OuterClass();
            System.out.println("实例变量通过外部类实例访问: " + outer.instanceVar);
        }
    }
}

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.accessMembers();
    }
}

这段代码展示了静态嵌套类如何访问外部类的静态成员，以及如何通过外部类的实例访问非静态成员。

4. 局部内部类

定义位置

• 位置：局部内部类是在方法、构造器或者代码块内部定义的类。这意味着它的作用域局限于该方法、构造器或代码块，不能在定义它的外部访问。

访问限制

• 外部类成员：局部内部类可以访问外部类的所有成员，包括私有成员，这与成员内部类相似。
• 局部变量：对于局部内部类而言，它可以访问定义在所在方法、构造器或代码块中的局部变量，但这些局部变量必须是final或effectively final（即虽然没有明确声明为final，但实际上在初始化后没有被重新赋值的变量）。这是因为在局部内部类中创建的对象可能在定义它的方法结束后仍然存在，为了保证数据的一致性，局部变量的值不能改变。

用途

• 封装逻辑：局部内部类常用于封装处理特定任务的逻辑，尤其是逻辑上与外部方法紧密相关但不需要在整个类范围内暴露的逻辑。
• 回调实现：在需要传递一个实现了特定接口的实例给另一个方法时，可以使用局部内部类来创建这个实例，实现临时的接口逻辑，而不必单独定义一个类。
• 事件监听：在图形界面编程中，可以创建局部内部类来实现事件监听器接口，以此响应特定事件，这种方式使得监听逻辑与触发事件的代码紧密耦合，便于理解和维护。

示例代码：

public class LocalInnerClassExample {
    public void process() {
        final int localVariable = 10; // 必须是final或effectively final

        // 局部内部类
        class LocalClass {
            public void display() {
                System.out.println("访问外部类的成员: " + someField);
                System.out.println("访问局部变量: " + localVariable);
            }
        }

        LocalClass localInstance = new LocalClass();
        localInstance.display();
    }

    private String someField = "外部类成员";

    public static void main(String[] args) {
        LocalInnerClassExample example = new LocalInnerClassExample();
        example.process();
    }
}

这段代码展示了局部内部类如何访问外部类的成员和所在方法的局部变量，并且展示了局部内部类的一种典型应用场景。

5. 匿名内部类

定义与使用

• 定义：匿名内部类是没有名字的局部类，它直接在创建类实例的地方定义并初始化，常用于那些只需要一次使用的类实例场合，比如实现接口、继承抽象类以提供具体实现，或者作为事件处理器。
• 使用场景：常见的使用场景包括实现接口的回调函数、事件监听器、线程实现等，这些情况下类的定义和实例化往往紧随其使用，不需要多次复用。

语法特点

• 直接实例化：匿名内部类的定义和创建实例同时进行，格式通常为 new 父类构造器() | 接口() { 类体 }。
• 简洁性：相比常规的类定义和实例化，匿名内部类的语法更加紧凑，减少了代码量，提升了代码的可读性，尤其适合于小型、一次性使用的类实现。

限制

• 无构造方法：匿名内部类不能定义构造方法，因为没有类名，所以不能像常规类那样通过构造函数初始化。
• 访问权限：匿名内部类可以访问外部类的所有成员，包括私有成员。对于局部变量，与局部内部类一样，要求变量为final或effectively final，以确保变量值在内部类生命周期内保持不变。
• 单一继承：匿名内部类只能继承一个父类或实现一个接口，但不能同时实现多个接口或继承多个类（除非通过多重继承接口间接实现）。

示例代码：

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击了！");
    }
});

这段代码展示了匿名内部类的一个典型用法，即实现ActionListener接口作为按钮的点击事件监听器，直接在addActionListener方法调用处定义并实例化，简化了代码结构。

6. 内部类与继承

继承内部类

• 继承非静态内部类：与继承普通类相似，但需要注意的是，非静态内部类的实例总是与外部类的实例相关联。因此，继承非静态内部类的子类也需要一个外部类的实例。创建子类实例时，需要先创建外部类的实例，再通过该实例创建子类对象。

  public class Outer {
      class BaseInner {
          // 内部类方法
      }
  }
  
  public class DerivedInner extends Outer.BaseInner {
      public DerivedInner(Outer outer) {
          outer.super(); // 显式调用外部类的构造器
      }
  }
  
  // 使用示例
  Outer outer = new Outer();
  DerivedInner derived = new DerivedInner(outer);
  

• 继承静态嵌套类：静态嵌套类如同普通的类一样，继承时不需要外部类的实例。因此，继承静态嵌套类的行为与继承普通类完全相同。

  public static class StaticNestedClass {
      // 静态嵌套类内容
  }
  
  public class DerivedStaticNestedClass extends Outer.StaticNestedClass {
      // 继承静态嵌套类的实现
  }
  

覆盖内部类的方法

• 访问权限：在覆盖内部类的方法时，必须遵守Java的访问权限规则。这意味着覆盖的方法不能有更严格的访问权限（例如，不能将public改为private）。

• 外部类成员的访问：继承内部类时，子类可以访问外部类的公共和保护成员，但不能直接访问外部类的私有成员，除非通过父内部类的方法（如果这些方法提供了访问途径）。

  public class Outer {
      private String secret = "private";
      protected String protectedSecret = "protected";
  
      class Inner {
          String getSecret() {
              return secret; // 可以访问私有成员
          }
      }
  }
  
  public class DerivedInner extends Outer.Inner {
      @Override
      public String getSecret() {
          return super.getSecret(); // 通过父类方法间接访问私有成员
      }
  }
  

综上所述，继承内部类时，特别是非静态内部类，需要考虑其与外部类实例的关联性，而在覆盖内部类方法时，要确保遵守访问权限规则，并理解如何通过内部类的结构访问外部类的成员。