java - 区分初始化器中声明的实例和静态内部类

Question

在尝试回答有关 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 参数的构造函数(如上面的情况)。在这种情况下，我无法安全地判断该类是内部类还是静态内部类。

还有另一种安全的方法吗？

仅供记录:这是一个理论问题，我目前没有尝试实现任何目标。

编辑:

这是我的 SSCCE:

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 {}})有一个声明类，是成员类并且具有 static 类修饰符<
• 在实例方法中创建的内部类具有封闭方法
• 在静态方法中创建的内部类有一个带有 static 修饰符的封闭方法
• 在初始化程序(静态或实例)中创建的内部类就是此处描述的情况，除了构造函数参数之外没有任何不同

Answer 1

您正在 Outer 中声明两个匿名内部类。

理论上(即我没有测试过)，我想你可以调用:

Class<?>[] classes = Outer.class.getDeclaredClasses();
for(Class<?> c : classes) {
  if ((c.getModifiers() & Modifier.STATIC) != 0) {
    // its a static inner class (or interface)
  }
  else {
    // its a non static inner class or interface
  }
}