Java内部类与匿名类的深度剖析：嵌套类的10大用法

# 1. Java内部类与匿名类概述

在Java编程语言中，内部类和匿名类是面向对象编程的重要组成部分。内部类为类的设计者提供了在其他类内部定义类的能力，而匿名类则允许开发者在声明类的同时创建其实例，通常用于简化代码和实现一次性接口或事件监听器。本章将带你概览这两种特性，为深入探讨它们的类型、特性、应用场景及其优化方法打下基础。

内部类作为Java强大的功能之一，让开发者能够创建更加封装的代码结构。通过这种方式，一个类可以包含另一个类的定义，这在许多复杂的应用场景中提供了便利，例如在实现监听器模式、模拟闭包功能等。内部类的实现是通过在外部类的代码体中直接定义一个新的类来实现的。然而，匿名类为这种封装提供了一个更加便捷的实现方式，尤其在需要快速实现接口或者简化事件驱动编程时特别有用。接下来的章节，我们将深入了解这些概念及其具体用法。

# 2. 内部类的类型和特性

2.1 内部类的基本概念

### 2.1.1 内部类的定义和访问规则

在Java编程语言中，内部类是一种定义在其他类的内部的类。内部类可以访问其外部类的所有成员（包括私有成员），这使得内部类可以作为外部类的辅助类，用于实现更复杂的功能。定义内部类时，其权限修饰符可以是`public`、`protected`、默认（无修饰符）、`private`，其访问权限与外部类成员的访问规则一致。

内部类的实例必须绑定到外部类的实例上，使用`外部类名.this.内部类名`的方式来创建。在非静态内部类中可以使用`外部类名.this`来引用外部类的实例。

class OuterClass {
    class InnerClass {
        void display() {
            System.out.println("Inner class is accessing instance of outer class.");
        }
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

### 2.1.2 内部类与外部类的关系

内部类和外部类之间存在着密切的关系。内部类持有对外部类的隐式引用，这一点在内部类访问外部类成员变量或方法时表现得尤为明显。内部类可以被声明为`static`或非`static`，这决定了内部类与外部类实例之间的绑定关系。

- 非静态内部类：非静态内部类的每个实例都隐式地持有其外部类实例的引用。非静态内部类可以访问外部类的所有成员，包括实例变量和方法。
- 静态内部类：静态内部类不需要依赖外部类的实例。它不能直接访问外部类的实例成员，但可以通过外部类的实例来访问。静态内部类使用`外部类名.内部类名`来声明。

class OuterClass {
    static class StaticInnerClass {
        void display() {
            // Cannot access non-static field directly
            // System.out.println(nonStaticField);
            // Should be accessed through an instance of the outer class
            OuterClass outer = new OuterClass();
            System.out.println(outer.nonStaticField);
        }
    }
    String nonStaticField = "I'm an instance field";
    public static void main(String[] args) {
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.display();
    }
}

## 2.2 内部类的分类

### 2.2.1 成员内部类

成员内部类是最常见的一种内部类类型，它作为外部类的一个成员存在，和外部类的字段、方法一样，可以拥有访问修饰符和static修饰符。成员内部类可以访问外部类的所有成员变量和方法，包括私有成员。

public class Outer {
    private String greeting = "Hello!";

    public class Inner {
        public int repeat = 3;
        public void go() {
            for (int i = 0; i < repeat; i++) {
                System.out.println(greeting);
            }
        }
    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.go();
    }
}

### 2.2.2 局部内部类

局部内部类是定义在方法或作用域内的内部类。它们只能在定义它们的方法或作用域内部使用，且具有访问该作用域局部变量的能力，这些局部变量必须被声明为`final`。局部内部类可以访问外部类的成员变量和方法，也可以访问方法或作用域内定义的局部变量。

class OuterClass {
    void display(final int x) {
        class LocalInnerClass {
            void print() {
                System.out.println("Value of x is: " + x);
            }
        }
        LocalInnerClass lic = new LocalInnerClass();
        lic.print();
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display(10);
    }
}

### 2.2.3 静态内部类

静态内部类不依赖于外部类的实例，它可以单独存在。静态内部类的实例化不需要外部类的实例，且不能直接访问外部类的非静态成员变量和方法。在静态内部类中，可以创建静态变量和方法。

public class Outer {
    private static String staticField = "I'm static!";

    static class StaticInnerClass {
        public void display() {
            // Can access static members directly
            System.out.println(staticField);
        }
    }
    public static void main(String[] args) {
        Outer.StaticInnerClass sic = new Outer.StaticInnerClass();
        sic.display();
    }
}

## 2.3 内部类的高级特性

### 2.3.1 内部类的实例化过程

内部类的实例化过程涉及到外部类和内部类的交互。由于内部类与外部类的实例有关联，创建内部类实例时，必须先创建外部类实例。通过外部类实例，我们可以创建内部类的实例。

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

在静态内部类的情况下，由于不需要外部类的实例，因此其实例化过程与普通类相同，不需要外部类实例。

OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();

### 2.3.2 内部类的上下文关系

内部类在创建时，会在内部类的实例中保留一个对外部类实例的引用。这个引用是Java虚拟机自动处理的，因此，内部类的实例总是可以访问外部类的实例及其成员变量和方法。内部类持有的这个引用使得其在某些情况下表现出独特的功能，如局部内部类访问方法作用域中的局部变量。

class Outer {
    private int number = 10;

    void display() {