在尝试回答一个SO上的问题时，我遇到了一个理论性问题，我不确定是否存在更好的解决方案：
假设我们有以下设置：
class A {
public A(Outer o) {
}
}
class Outer {
static A staticA = new A( new Outer() ) {
...
};
A innerA = new A( new Outer() ) {
...
};
}
如何使用反射区分内部类和静态内部类？
从我的测试中，我只能通过检查构造函数的参数类型来判断哪个是静态内部类，即
innerA类只提供一个需要两个Outer实例参数的构造函数。(我测试了我能想到的所有封闭类/方法的标志或数据，所有东西都相等，但我可能会错过一些东西。)在比较这两个类时，可以通过检查哪个构造函数具有更少的外部类型的参数来确定哪个是静态内部类(在这种情况下，静态内部类的构造函数将少一个)。
然而，假设我不知道类的信息，特别是我不知道构造函数是否有任何外部类型的显式参数，即
A是否具有无参构造函数或一个带 Outer 参数的构造函数(就像上面的例子一样)。在那种情况下，我不能安全地判断该类是内部类还是静态内部类。是否还有其他安全的方式？
仅供记录：这是一个理论问题，我目前没有试图实现任何内容。
以下是示例代码：
package sscce;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
public class ReflectionTest {
public static void main(String... args) {
Outer o = new Outer();
o.innerA.reflect();
o.staticA.reflect();
}
}
class A {
public A( Outer o ) {
}
public void reflect() {
Class<?> c = getClass();
Class<?> e = c.getEnclosingClass();
Class<?> d = c.getDeclaringClass();
Constructor<?> enc = c.getEnclosingConstructor();
Method m = c.getEnclosingMethod();
System.out.println("class: " + c.getName());
System.out.println("-------------------");
System.out.println("enclosing class: " + e);
System.out.println("enclosing ctor: " + enc);
System.out.println("enclosing method: " + m);
System.out.println("declaring class: " + d);
System.out.println("anonymous: " + c.isAnonymousClass());
System.out.println("local: " + c.isLocalClass());
System.out.println("synth: " + c.isSynthetic());
System.out.println("member: " + c.isMemberClass());
System.out.println("modifiers: " + c.getModifiers());
for( Constructor<?> ctr : c.getDeclaredConstructors() ) {
System.out.println("constructor params:" + Arrays.toString( ctr.getParameterTypes()) );
}
System.out.println();
}
}
class Outer {
public static A staticA = new A(new Outer()) {};
public A innerA = new A(this) {};
}
输出结果如下：
class: sscce.Outer$2 //this is innerA
-------------------
enclosing class: class sscce.Outer
enclosing ctor: null
enclosing method: null
declaring class: null
anonymous: true
local: false
synth: false
member: false
modifiers: 0
constructor params:[class sscce.Outer, class sscce.Outer]
class: sscce.Outer$1 //this is staticA
-------------------
enclosing class: class sscce.Outer
enclosing ctor: null
enclosing method: null
declaring class: null
anonymous: true
local: false
synth: false
member: false
modifiers: 0
constructor params:[class sscce.Outer]
编辑2：:
为了完整起见，我添加了其他一些情况，并且这些情况都是可以区分的（除了当前列表中的最后一个）：
- “普通”内部类（
class Outer { class Inner {}}）有一个声明类并被标记为成员类 - “普通”静态内部类（
class Outer { static class Inner {}}）有一个声明类，是成员类 并且 有静态类修饰符 - 在实例方法中创建的内部类具有封闭方法
- 在静态方法中创建的内部类具有带有静态修饰符的封闭方法
- 在初始化程序（静态或实例）中创建的内部类是在此处描述的情况，除了构造函数参数外，它们没有区别
new A(...) {}末尾的大括号。 - Jon Skeet