Java 类文件命名规范详解

1. 概述

在 Java 中，每当一个类被编译时，编译器会生成一个与该类同名的 .class 文件。但如果涉及到嵌套类（nested class）或嵌套接口（nested interface），情况就会有所不同——编译器会使用一种特殊的命名方式来生成类文件名，其中会包含外层类和内层类的名字，并以美元符号 $ 分隔。

本文将详细探讨各种嵌套结构在编译时是如何生成对应的 .class 文件的，包括嵌套类、局部类、匿名类、嵌套接口以及枚举类型。

2. 嵌套类与嵌套接口

在 Java 中，我们可以在一个类内部定义另一个类，这种类被称为 嵌套类（nested class）。外层类称为 外部类（outer class），嵌套类的作用域受限于其外部类。

类似地，我们也可以在类或接口中定义接口，称为 嵌套接口（nested interface）。

嵌套类和接口的使用场景通常是将逻辑上紧密相关的组件封装在一起，这样不仅代码结构更清晰，也提高了封装性。

下面我们将逐一介绍这些结构及其编译后生成的类文件命名规则。

3. 嵌套类

嵌套类是在另一个类或接口中定义的类。当我们需要一个辅助类，但又不希望它暴露在外部时，嵌套类是一个很好的选择。

编译时，编译器会为外部类生成一个与类名相同的 .class 文件，同时为每个嵌套类生成单独的 .class 文件。嵌套类的文件命名规则为：

✅ OuterClassName$NestedClassName.class

3.1. 静态嵌套类（Static Nested Classes）

静态嵌套类是使用 static 关键字定义的嵌套类。它与外部类的实例无关，可以直接通过外部类访问。

public class Outer {
    static class StaticNested {
        public String message() {
            return "This is a static Nested Class";
        }
    }
}

编译后生成两个文件：

• Outer.class
• Outer$StaticNested.class

3.2. 非静态嵌套类（Non-Static Nested Classes）

也称为 内部类（inner class），它与外部类的实例绑定，可以访问外部类的所有成员。

public class Outer {
    class Nested {
        public String message() {
            return "This is a non-static Nested Class";
        }
    }
}

编译后生成：

• Outer.class
• Outer$Nested.class

3.3. 局部类（Local Classes）

局部类是在方法、循环、条件语句等代码块中定义的类。它只能在定义它的代码块中使用。

public String message() {
    class Local {
        private String message() {
            return "This is a Local Class within a method";
        }
    }
    Local local = new Local();
    return local.message();
}

编译后生成：

• Outer.class
• Outer$1Local.class

⚠️ 如果在不同代码块中定义了同名的局部类，编译器会自动编号区分，如 Outer$1Local.class 和 Outer$2Local.class。

public String message(String name) {
    if (StringUtils.isEmpty(name)) {
        class Local {
            private String message() {
                return "This is a Local class within if clause";
            }
        }
        Local local = new Local();
        return local.message();
    } else
        return "Welcome to " + name;
}

生成的类文件：

3.4. 匿名内部类（Anonymous Inner Classes）

匿名类是没有名字的内部类，通常用于实现接口或继承类。

public String greet() {
    Outer anonymous = new Outer() {
        @Override
        public String greet() {
            return "Running Anonymous Class...";
        }
    };
    return anonymous.greet();
}

编译后生成：

• Outer.class
• Outer$1.class

同样可以用于实现接口：

interface HelloWorld {
    public String greet(String name);
}

public String greet(String name) {
    HelloWorld helloWorld = new HelloWorld() {
        @Override
        public String greet(String name) {
            return "Welcome to "+name;
        }
    };
    return helloWorld.greet(name);
}

生成的类文件：

3.5. 接口中的嵌套类

我们也可以在接口中定义类，通常用于提供接口方法的默认实现。

interface HelloWorld {
    public String greet(String name);
    class InnerClass implements HelloWorld {
        @Override
        public String message(String name) {
            return "Inner class within an interface";
        }
    }
}

编译后生成：

• HelloWorld.class
• HelloWorld$InnerClass.class

4. 嵌套接口

嵌套接口是定义在类或接口中的接口。主要用途是组织相关的接口，避免命名冲突。

4.1. 接口中的接口

interface HelloWorld {
    public String greet(String name);
    
    interface HelloSomeone{
        public String greet(String name);
    }
}

生成：

• HelloWorld.class
• HelloWorld$HelloSomeone.class

4.2. 类中的接口

public class Outer {
     interface HelloOuter {
        public String hello(String name);
    }
}

生成：

• Outer.class
• Outer$HelloOuter.class

5. 枚举（Enums）

枚举是 Java 5 引入的特性，是一种特殊的类，用于定义一组常量。

5.1. 独立枚举

enum Level {
    LOW, MEDIUM, HIGH;
}

编译后生成：

• Level.class

5.2. 类中的枚举

public class Outer {
    enum Color{ 
        RED, GREEN, BLUE; 
    }
}

生成：

• Outer.class
• Outer$Color.class

5.3. 接口中的枚举

interface HelloWorld {
    enum DIRECTIONS {
        NORTH, SOUTH, EAST, WEST;
    }
}

生成：

• HelloWorld.class
• HelloWorld$DIRECTIONS.class

5.4. 枚举中的枚举

enum Foods {
    DRINKS, EATS;
    enum DRINKS {
        APPLE_JUICE, COLA;
    }
    enum EATS {
        POTATO, RICE;
    }
}

编译后生成多个类文件：

6. 总结

本文详细介绍了 Java 中各种嵌套结构（类、接口、枚举）在编译时生成的 .class 文件命名规则。合理理解这些规则，有助于排查类加载、反射、打包等问题。

本文代码示例可从 GitHub 仓库 获取。