为什么 class.getConstructor(parameters) 不允许子对象作为参数？

Question

假设我有一个父类和一个扩展我的父类的子类，并且我有以下代码。

public class SomeClass {
  private Parent myParent;

  public SomeClass(Parent myParent) {
    this.myParent = myParent;
  }
}

为什么允许这样做

Class<SomeClass> clazz = SomeClass.class;
SomeClass someClass = clazz.getConstructor(Parent.class).getInstance(Child);

这不是

Class<SomeClass> clazz = SomeClass.class;
SomeClass someClass = clazz.getConstructor(Child.class).getInstance(Child);

第二个抛出 NoSuchMethodeException。为什么在这种情况下没有动态绑定但是​​使用普通的构造函数动态绑定就可以了？ 有没有办法解决这个问题？

编辑： 我正在尝试在运行时加载 jar 文件。此时我有我需要的类，加载了URLClassLoader 。接下来，我想创建一个已加载类的新实例。要创建实例，我调用urlClassLoader.loadClass(nameOfClass).getConstructor(parameterType).newInstance(initArguments); 在这种情况下，parameterType 将是 child.class。

Answer 1

下面的方法getConstructorAcceptingSupertype 找到一个接受给定参数类型或其超类型之一的构造函数。

import java.lang.reflect.Constructor;

public class ConstructorTester {
    
    public ConstructorTester(Object o) {
        System.out.println("Object constructor");
    }
    
    public ConstructorTester(CharSequence o) {
        System.out.println("CharSequence constructor");
    }
    
    public static void main(String[] args) throws Throwable {
        Object[] arg = {null};
        getConstructorAcceptingSupertype(ConstructorTester.class, Object.class).newInstance(arg); //Object constructor
        getConstructorAcceptingSupertype(ConstructorTester.class, CharSequence.class).newInstance(arg); //CharSeq constructor
        getConstructorAcceptingSupertype(ConstructorTester.class, Integer.class).newInstance(arg); //Object constructor
        getConstructorAcceptingSupertype(ConstructorTester.class, String.class).newInstance(arg); //CharSeq constructor
        getConstructorAcceptingSupertype(ConstructorTester.class, StringBuilder.class).newInstance(arg); //CharSeq constructor
    }
    
    /**
     * Returns a one-arg {@link Constructor} from {@code clazz} that accepts the given {@code parameterType}. This
     * method guarantees that there is no other one-arg constructor in {@code clazz} that accepts a superclass or
     * superinterface of the type that the returned constructor accepts. 
     */
    private static Constructor<?> getConstructorAcceptingSupertype(Class<?> clazz, Class<?> parameterType) {
        Constructor<?> correctConstructor = null;
        for(Constructor<?> constructor : clazz.getConstructors()) {
            if( constructor.getParameterCount() == 1 &&
                constructor.getParameters()[0].getType().isAssignableFrom(parameterType)) {
                if(correctConstructor == null) {
                    correctConstructor = constructor;
                }
                else { //see if this constructor is more specific than the current correctConstructor.
                    Class<?> currentType = correctConstructor.getParameters()[0].getType();
                    Class<?> newType = constructor.getParameters()[0].getType();
                    if(currentType.isAssignableFrom(newType))
                        correctConstructor = constructor;
                }
            }
        }
        if(correctConstructor == null)
            throw new IllegalArgumentException("No one-arg constructor exists that accepts the given parameter type");
        return correctConstructor;
    }
    
}

请注意，没有办法避免一个模棱两可的情况，比如C，扩展了另外两个接口A 和B，并且你的类有两个构造函数（SomeClass(A) 和SomeClass(B)） .在这种情况下，即使是像new SomeClass(instanceOfC) 这样的显式构造函数调用也会在编译时失败。在这种情况下，我上面的方法将返回任意构造函数（SomeClass(A) 或 SomeClass(B)），但不保证是哪个。

Answer 2

问题是w.l.o.g. 无法解决，因为我们可以创建模棱两可的示例。考虑以下示例：

interface Foo {}

class Bar {
  public Bar() {}

  public Bar(Bar other) {}

  public Bar(Foo other) {}
}

class Baz extends Bar implements Foo {}

如果我们现在调用new Bar(new Baz())，程序将无法编译。

Ideone demo

因此，Class.getConstructor(Class<?>... parameterTypes) interprets the types as formal parameters, not actual parameters。

---

我强烈建议不要实施在上述情况下为我们“选择”构造函数的解决方案。相反，我会选择：

• 要么抛出一些Exception，表示无法确定单数构造函数，要么
• 返回List<Constructor<?>>。

对于第二种方法（返回List<...>），我们可以使用以下代码：

public static List<Constructor<?>> getConstructorsFromTypeFittingActualParameters(
    Class<?> type,
    Class<?>... actualParameters) {
  final Class<?>[] actualParametersNotNull = 
      Optional.ofNullable(actualParameters).orElseGet(() -> new Class<?>[0]);
  return Arrays.stream(type.getConstructors())
      .filter(constructor -> constructor.getParameterCount() == actualParametersNotNull.length)
      .filter(constructor -> formalParameterTypesAcceptActualParameterTypes(
          constructor.getParameterTypes(),
          actualParametersNotNull))
      .collect(Collectors.toList());
}

private static boolean formalParameterTypesAcceptActualParameterTypes(
    Class<?>[] formalParameterTypes,
    Class<?>[] actualParameterTypes) {
  Objects.requireNonNull(formalParameterTypes);
  Objects.requireNonNull(actualParameterTypes);
  if (formalParameterTypes.length != actualParameterTypes.length) {
    throw new IllegalArgumentException();
  }

  for (int index = 0; index < formalParameterTypes.length; ++index) {
    if (!formalParameterTypes[index].isAssignableFrom(actualParameterTypes[index])) {
      return false;
    }
  }
  return true;
}

给定上面的例子，这个实现将返回两个构造函数。

Ideone example