在Java中使用反射来设置方法的参数

Question

I am trying to achieve something approximating the following:

public class MyClass<E>
{
    protected MyClass(Object[] variables)
    {
        //init
    }

    public MyClass(Comparator<? super E> comp, Object[] variables)
    {
        //init
    }

    public static <K extends Comparable<? super K>, T extends MyClass<K>> 
         T construct(T example, Object[] variables)
    {
        return new T(variables);
    }
}

Where the Object[] variables is not the actual code, but rather a placeholder for whatever the actual parameters for construction are.

Therein lies my question. I have seen plenty of examples, both with and without reflection, of how to do this when the parameters of T's constructor are known ahead of time, and can thus be specified within construct's parameters. However, I would like to be able to do this even when the parameters of T's constructor are unknown. Is there a way to do this?

I don't particularly care if the solution uses reflection or not so long as it works, but reflection seemed the most likely option.

I am fairly new to reflection as a whole, so I apologize if this question is fairly basic.

Edit: Due to feedback that there is no way to dynamically set the parameters of construct() I would like to alter the question slightly.

Assuming that the protected constructor has the required parameters for the class's construction, if I use a vararg (public static <K extends Comparable<? super K>, T extends MyClass<K>> T construct(T example, Object... variables)) what would be the best way of ensuring that the arguments passed in to variables match the parameters required for the constructor? I had hoped to do this dynamically, because then the compiler itself would prevent such issues, but without this possibility I ask for the best alternate solution.

Edit: For clarification, this is my actual goal: I want MyClass to accept either a parameterization, E, that extends Comparable or any parameterization, but have a Comparator passed in. I can achieve the second goal simply through a constructor, but in order to leave E open to any option in the second case, I have to leave it open to any option overall. To deal with this, I made the general constructor protected and made a public static method to force the Comparable implementation and act as a pseudo-constructor, with the return type being MyClass where K is Comparable. However, this causes problems when another class extends MyClass. If I know beforehand that the inheriting class will have the same parameters as MyClass, then I can simply hide the method and alter the return type accordingly. But if I want to have the subclass have different parameters, then I've altered the signature of the method and can no longer use it to hide the previous one, meaning that the subclass can not only return an instance of itself, but also a completely different instance of its parent. This is what I would like to try to avoid.

Answer 1

This may work, but I would not recommend it. Note, for this to work example and all members of variables MUST BE not null

public static <K extends Comparable<? super K>, T extends MyClass<K>> 
     T construct(T example, Object[] variables) throws 
                 NoSuchMethodException,
                 SecurityException,
                 InstantiationException,
                 IllegalAccessException,
                 IllegalArgumentException,
                 InvocationTargetException 
{
    Objects.requireNotNull(example);

    Class<?>[] argTypes = new Class<?>[variables.length];
    for ( int i = 0; i < variables.length; ++i)
    {
        // This will NPE if variables[i] is null
        argTypes[i] = variables[i].getClass();
    }

    // This will throw, if constructor is not defined
    Constructor<?> constructor = example.getClass().getConstructor(argTypes);

    return (T) constructor.newInstance(variables);
}

Usually, what you are doing, can be achieved by creating a Factory interface that creates instances of specific class.

Answer 2

I don't think you need to go into reflection. You just need to simplify what you need and use the power of java and generics for your needs. Here is an example according to your third edit:

class MyClass<E> {
    private Comparator<MyClass<E>> comparator;

    public MyClass(List<Object> params, Comparator<MyClass<E>> comparator) {
        //init
        this.comparator = comparator;
    }

}
class  MyClassExtension extends MyClass<Integer> {

    public MyClassExtension(List<Object> params, Comparator<MyClass<java.lang.Integer>> comparator) {
        super(params, comparator);
    }
}
class  MyClassExtension2<E> extends MyClass<E> {

    public MyClassExtension2(List<Object> params, Comparator<MyClass<E>> comparator) {
        super(params, comparator);
    }
}

Answer 3

I think I may have realized a potential solution on my own, though I would like feedback as to it's viability.

public class MyClass<E>
{
    public MyClass(Comparable<? super E> example, E example2, Object[] variables) 
      throws IllegalArgumentException
    {
        if(!example.getClass().equals(example2.getClass())
        {
             throw new IllegalArgumentException();
        }
        //init
    }

    public MyClass(Comparator<? super E> comp, Object[] variables)
    {
        //init
    }
}

The idea is that the if statement forces example to be the same class as the generic E, and the presence of example as a parameter forces that class to implement Comparable.