编译后生成的类文件

类名规则及编译后产生的类文件

javac -encoding utf-8  ExternalClass.java
java ExternalClass
// 结果
外部类 : ExternalClass
内部静态类 : ExternalClass$InnerStaticClass
内部成员类 : ExternalClass$MemberClass
局部内部类 : ExternalClass$1LocalNestedClass
匿名内部类 : ExternalClass$1
lambda表达式类 : ExternalClass$$Lambda$1/834600351
Java动态代理类 : com.sun.proxy.$Proxy0

import java.lang.reflect.Proxy;

/**
 * Java类类名规则
 * ExternalClass.class
 */
public class ExternalClass {

    /**
     * 静态内部类
     * ExternalClass$InnerStaticClass.class
     * 类名：【外部类】$【静态内部类】 ，和外部类无太多关系，
     * 只是能在外部类的静态方法中访问次静态类，比如在main方法中可以直接 new InnerStaticClass()
     */
    static class InnerStaticClass {}

     /**
     * 内部成员类
     * 内部成员类 ExternalClass$MemberClass.class
     * 类名：【外部类】$【内部成员类】
     */
    public class MemberClass {}
    public void memberClass() {
        System.out.println("内部成员类 : " + MemberClass.class.getName());
    }

    /**
     * 局部内部类
     * ExternalClass$1LocalNestedClass.class
     * 类名：【外部类】$【数字】【局部内部类】
     */
    public void localNestedClass() {
        class LocalNestedClass {}
        System.out.println("局部内部类 : " + LocalNestedClass.class.getName());
    }

    /**
     * 匿名内部类（匿名类没有名字,匿名类不管是成员匿名类还是局部匿名类，都是一样的规则）
     * ExternalClass$1.class
     * 类名：【外部类】$【数字】
     */
    public void anonymousClass() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
            }
        };
        System.out.println("匿名内部类 : " + runnable.getClass().getName());
    }

    /**
     * lambda表达式类（不会生成.class文件）
     * ExternalClass$$Lambda$1/834600351
     * 类名：【外部类】$$Lambda$【数字】
     */
    public void lambdaExpressionClass() {
        Runnable runnable = () -> {};
        System.out.println("lambda表达式类 : " + runnable.getClass().getName());
    }

    /**
     * Java动态代理类（不会生成.class文件，只会生成ProxyClass.class文件）
     * 类名：$Proxy【数字】
     */
    public void proxyClass() {
        Object obj = Proxy.newProxyInstance(ExternalClass.class.getClassLoader(), 
                              new Class[]{Runnable.class}, new ProxyClass());
        System.out.println("Java动态代理类 : " + obj.getClass().getName());
    }

    public static void main(String[] args) {
        System.out.println("外部类 : " + ExternalClass.class.getName());
        System.out.println("内部静态类 : " + InnerStaticClass.class.getName());

        ExternalClass obj = new ExternalClass();
        obj.memberClass();
        obj.localNestedClass();
        obj.anonymousClass();
        obj.lambdaExpressionClass();
        obj.proxyClass();
    }

}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyClass implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}