编辑“︁Java静态内部类”︁

= Java静态内部类 =

静态内部类是Java中四种内部类之一，它与其他内部类的关键区别在于其静态特性。本条目将详细讲解静态内部类的定义、特性、使用场景及实际应用。

== 定义与基本特性 ==
'''静态内部类'''（Static Nested Class）是使用<code>static</code>关键字声明的嵌套类。其核心特性包括：
* 不依赖外部类的实例（可直接通过外部类名访问）
* 只能直接访问外部类的静态成员（包括私有静态成员）
* 可声明静态和非静态成员
* 编译后会生成独立的<code>OuterClass$InnerClass.class</code>文件

数学表示为：若外部类为<math>Outer</math>，则静态内部类为<math>Outer.Inner</math>。

== 语法结构 ==
基本声明方式：
<syntaxhighlight lang="java">
class OuterClass {
    private static int staticField = 10;
    
    static class StaticInnerClass {
        void display() {
            System.out.println("外部类的静态字段: " + staticField);
        }
    }
}
</syntaxhighlight>

== 实例化方式 ==
静态内部类的实例化不需要外部类实例：
<syntaxhighlight lang="java">
public class Main {
    public static void main(String[] args) {
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.display();  // 输出: 外部类的静态字段: 10
    }
}
</syntaxhighlight>

== 与普通内部类的对比 ==
{| class="wikitable"
|-
! 特性 !! 静态内部类 !! 普通内部类
|-
| 依赖外部实例 | 否 | 是
|-
| 访问外部成员 | 仅静态成员 | 所有成员
|-
| 包含静态成员 | 允许 | 不允许（常量除外）
|}

<mermaid>
graph LR
    A[外部类] --> B[静态内部类]
    A --> C[非静态内部类]
    B --> D[可独立实例化]
    C --> E[需外部实例]
</mermaid>

== 典型应用场景 ==
=== 1. 工具类封装 ===
将相关工具方法组织在静态内部类中：
<syntaxhighlight lang="java">
class CollectionUtils {
    static class Sorting {
        static void quickSort(int[] arr) {
            // 快速排序实现
        }
    }
}
// 调用方式
CollectionUtils.Sorting.quickSort(array);
</syntaxhighlight>

=== 2. Builder模式实现 ===
静态内部类常用于实现Builder模式：
<syntaxhighlight lang="java">
class Computer {
    private final String CPU;
    private final String RAM;

    private Computer(Builder builder) {
        this.CPU = builder.CPU;
        this.RAM = builder.RAM;
    }

    static class Builder {
        private String CPU;
        private String RAM;

        Builder setCPU(String cpu) {
            this.CPU = cpu;
            return this;
        }

        Builder setRAM(String ram) {
            this.RAM = ram;
            return this;
        }

        Computer build() {
            return new Computer(this);
        }
    }
}
// 使用示例
Computer pc = new Computer.Builder()
    .setCPU("i7")
    .setRAM("16GB")
    .build();
</syntaxhighlight>

== 高级特性 ==
=== 访问权限控制 ===
静态内部类支持完整的访问修饰符：
* <code>public static class</code> - 全局可访问
* <code>private static class</code> - 仅外部类可见
* 包级私有（默认） - 同包可见

=== 多级嵌套 ===
支持多层静态嵌套（但通常不建议超过两层）：
<syntaxhighlight lang="java">
class Outer {
    static class Level1 {
        static class Level2 {
            static void method() {
                System.out.println("多级嵌套示例");
            }
        }
    }
}
// 调用链
Outer.Level1.Level2.method();
</syntaxhighlight>

== 性能考量 ==
* 静态内部类不持有外部类引用（无内存泄漏风险）
* 实例化开销与普通类相同
* 适合需要频繁创建的辅助类

== 常见误区 ==
1. '''错误认知'''：静态内部类不能访问外部类任何成员<br>
   '''事实'''：可以访问所有静态成员，包括私有静态成员

2. '''错误用法'''：尝试访问外部类实例成员<br>
   <syntaxhighlight lang="java">
   class Outer {
       int instanceField;
       static class Inner {
           void errorMethod() {
               System.out.println(instanceField);  // 编译错误
           }
       }
   }
   </syntaxhighlight>

== 最佳实践建议 ==
* 优先考虑静态内部类（除非需要访问外部实例成员）
* 保持内部类短小专注（通常不超过200行）
* 使用清晰的命名规范（如<code>XxxUtils</code>、<code>XxxBuilder</code>）
* 避免过度嵌套（超过两级会降低可读性）

静态内部类是Java封装性和代码组织的重要工具，合理使用可以显著提高代码的可维护性和模块化程度。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java内部类]]