【Java内部类与枚举类的进阶用法】：设计模式实践与案例分析

# 1. Java内部类与枚举类概述

Java语言在设计时就提供了一套丰富的类结构，以便开发者能够构建出更加清晰和可维护的代码。其中，内部类和枚举类是Java语言特性中的两个重要概念，它们为Java编程提供了额外的灵活性和表达能力。

在本章节，我们将首先概述什么是内部类和枚举类，它们在Java编程中的基本用途和优势。我们将简要讨论内部类和枚举类在提高封装性、设计模式实现和代码组织上的作用。这一章旨在为读者提供一个基础知识框架，为后续章节的深入探讨奠定基础。

# 2. 深入理解Java内部类

### 2.1 内部类的分类与特性

#### 2.1.1 成员内部类和静态内部类
Java内部类的两个基本分类是成员内部类（Member Inner Classes）和静态内部类（Static Inner Classes）。成员内部类最常见，它可以访问外部类的所有成员（字段和方法），包括私有成员，也包括实例方法。静态内部类与成员内部类最大的区别是静态内部类不能访问外部类的非静态成员。

代码块：

public class OuterClass {
    private String message = "Hello, this is OuterClass!";

    // 成员内部类
    class MemberInnerClass {
        void printMessage() {
            System.out.println(message);
        }
    }

    // 静态内部类
    static class StaticInnerClass {
        void printMessage() {
            // System.out.println(message); // 编译错误: cannot find symbol
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.MemberInnerClass inner = outer.new MemberInnerClass();
        inner.printMessage(); // 正确，输出 "Hello, this is OuterClass!"

        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.printMessage(); // 正确，但此处无输出，因为不能访问外部类私有字段
    }
}

#### 2.1.2 局部内部类和匿名内部类
局部内部类定义在方法或作用域内，与成员内部类和静态内部类不同，它们没有访问权限修饰符，且仅在定义它们的作用域内有效。匿名内部类是局部内部类的一个特例，通常用来实现单次使用的接口或抽象类。

代码块：

public class OuterClass {
    // 普通局部内部类
    void display() {
        class LocalInnerClass {
            void displayInfo() {
                System.out.println("Local Inner Class");
            }
        }
        LocalInnerClass lic = new LocalInnerClass();
        lic.displayInfo();
    }

    // 匿名内部类
    void createAnonymousInner() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Inner Class");
            }
        };
        runnable.run();
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
        outer.createAnonymousInner();
    }
}

### 2.2 内部类的访问规则和作用域

#### 2.2.1 内部类对外部类的访问
内部类可以访问外部类的所有成员，包括私有成员。这是通过内部类维护一个指向外部类对象的隐式引用实现的。在内部类的方法中，可以通过外部类名（`OuterClassName.this`）来引用外部类的成员。

代码块：

public class OuterClass {
    private String name = "Outer Name";

    class MemberInnerClass {
        void printName() {
            System.out.println(OuterClass.this.name);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.MemberInnerClass inner = outer.new MemberInnerClass();
        inner.printName(); // 正确，输出 "Outer Name"
    }
}

#### 2.2.2 内部类与外部类的变量遮蔽问题
当内部类和外部类中有同名变量时，内部类的变量会遮蔽外部类的变量。但可以通过`OuterClassName.this.variableName`语法访问外部类的变量。

代码块：

public class OuterClass {
    private String message = "Outer Message";

    class MemberInnerClass {
        String message = "Inner Message";

        void printMessages() {
            String message = "Local Message";
            System.out.println(message); // 本地变量
            System.out.println(this.message); // 内部类变量
            System.out.println(OuterClass.this.message); // 外部类变量
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.MemberInnerClass inner = outer.new MemberInnerClass();
        inner.printMessages();
    }
}

### 2.3 内部类的高级特性与应用

#### 2.3.1 内部类的实例化与作用域限制
内部类的实例化可以分为以下几种情况：
- 非静态内部类必须依赖外部类的实例。
- 静态内部类可以在不创建外部类实例的情况下进行实例化。
- 局部内部类只能在其所在的方法或者作用域内实例化。
- 匿名内部类适合用在那些只需要一次使用的场景。

代码块：

public class OuterClass {
    class NonStaticInnerClass {
        NonStaticInnerClass() {
            System.out.println("NonStaticInnerClass created");
        }
    }

    static class StaticInnerClass {
        StaticInnerClass() {
            System.out.println("StaticInnerClass created");
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.NonStaticInnerClass inner1 = outer.new NonStaticInnerClass();
        OuterClass.StaticInnerClass inner2 = new OuterClass.StaticInnerClass();

        final int x = 5; // 局部变量必须是final或实际上final
        class LocalInner