Java从入门到放弃（三十二）：内部类

在Java程序设计中，包（Package）是一种组织类和接口的方式，它类似于文件系统中的文件夹，用于将功能相关的类分组管理。通过包，我们可以有效地避免命名冲突，同时也能够清晰地表示出类之间的逻辑关系。

大多数情况下，我们会将相关的类放在同一个包下，这些类在包的层次结构中处于同一层级，它们之间并没有直接的父子关系。

除了这种常见的类组织方式，Java还提供了内部类（Nested Class）的概念。内部类是定义在另一个类内部的类。它可以访问外围类的成员，包括私有成员，这使得内部类非常适合用来实现与外围类紧密相关的功能。

Inner Class

在Java中，内部类（Inner Class）是一种定义在另一个类（称为外部类或外围类）内部的类。内部类与外部类之间的关系非常特殊，它不仅可以访问外部类的所有成员（包括私有成员），而且还拥有一个隐式的引用指向外部类的实例。

以下是一个简单的示例，展示了如何定义和使用内部类：

class Outer {
    class Inner {
        void hello() {
            System.out.println("Hello from Inner Class");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建外部类的实例
        Outer outer = new Outer();
        // 通过外部类的实例创建内部类的实例
        Outer.Inner inner = outer.new Inner();
        inner.hello(); // 调用内部类的方法
    }
}

在这个示例中，Inner类是Outer类的内部类。要创建Inner类的实例，我们必须首先创建一个Outer类的实例。这是因为Inner类的对象总是与Outer类的对象相关联，Inner类的对象持有对Outer类对象的引用。

此外，内部类还可以根据其访问权限和是否静态进一步细分为多种类型，例如成员内部类、局部内部类、匿名内部类和静态嵌套类。每种类型的内部类都有其特定的用途和行为。

内部类的一个重要特性是它们能够访问外部类的私有成员。这是因为内部类的作用域嵌套在外部类内部，因此它们被视为外部类的一部分。这种特性使得内部类非常适合用于实现与外部类紧密相关的功能，同时保持封装性和独立性。

Java编译器在编译包含内部类的代码时，会为内部类生成一个独立的.class文件，文件名通常为外部类$内部类.class。这种编译方式确保了内部类和外部类可以独立地被加载和使用，同时也保留了它们之间的关联关系。

Anonymous Class

匿名内部类是一种特殊的内部类，它允许我们在声明类的同时实例化它，而不需要为类命名。这种方式通常用于实现接口或继承类时，特别是当我们只需要使用一次这个类的实例时。匿名内部类可以简化代码，减少类名的重复定义。

以下是一个使用匿名内部类实现Runnable接口的例子：

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("Nested");
        outer.asyncHello();
    }
}

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    void asyncHello() {
        // 实现Runnable接口的匿名内部类
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello, " + name); // 访问Outer类的name字段
            }
        };
        new Thread(r).start();
    }
}

在这个例子中，Runnable接口要求实现一个run方法。我们在asyncHello方法内部定义了一个匿名内部类，并实现了run方法。这个匿名内部类可以访问外围类Outer的私有字段name，因为它与外围类有一层特殊的关系。

匿名内部类的另一个用途是继承自普通类。以下是一个匿名内部类继承自HashMap类的例子：

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // 创建普通的HashMap实例
        HashMap<String, String> map1 = new HashMap<>();
        // 创建匿名内部类继承自HashMap
        HashMap<String, String> map2 = new HashMap<>(){};

        // 创建匿名内部类继承自HashMap，并添加初始化代码块
        HashMap<String, String> map3 = new HashMap<>(){
            {
                put("A", "1");
                put("B", "2");
            }
        };

        System.out.println(map3.get("A")); // 输出: 1
    }
}

在这个例子中，map2是一个匿名内部类实例，它继承自HashMap。map3也是一个匿名内部类实例，但它还包含了一个初始化代码块，用于在实例创建时执行一些初始化操作。

Java编译器会为每个匿名内部类生成一个独立的.class文件，文件名通常为外部类$数字.class，其中数字表示该外部类中定义的匿名内部类的顺序。例如，如果Outer类中有多个匿名内部类，它们将被编译为Outer$1.class、Outer$2.class等。

Static Nested Class

静态内部类（Static Nested Class）是Java中一种特殊的内部类，它通过使用static关键字来修饰，从而区别于普通的内部类。静态内部类与外部类之间的关系不同于普通内部类，它不依赖于外部类的实例，因此可以独立于外部类的实例存在。

以下是一个静态内部类的示例：

public class Main {
    public static void main(String[] args) {
        // 静态内部类的实例不需要外部类的实例就可以创建
        Outer.StaticNested sn = new Outer.StaticNested();
        sn.hello();
    }
}

class Outer {
    private static String NAME = "OUTER";

    Outer() {
        // 构造器是私有的，防止外部类被实例化
    }

    // 静态内部类
    static class StaticNested {
        void hello() {
            // 可以访问外部类的静态字段和方法
            System.out.println("Hello, " + Outer.NAME);
        }
    }
}

在这个例子中，StaticNested是Outer的静态内部类。与普通内部类不同，StaticNested的实例可以在不需要Outer类实例的情况下创建。这意味着，静态内部类与外部类之间没有隐式的引用关系，因此不能使用Outer.this来引用外部类的实例。

静态内部类可以访问外部类的所有静态成员，包括私有的静态字段和静态方法。这是因为静态成员属于类级别，而不是实例级别。如果将静态内部类移动到外部类之外，它将无法访问外部类的私有静态成员，因为它不再与外部类有特殊的关系。

静态内部类通常用于实现与外部类紧密相关但不需要外部类实例化的功能。它们提供了一种封装和隐藏实现细节的方式，同时允许外部类的静态上下文与内部类共享。