通用类定义中的可变长度类型参数

Question

Is it possible to add variable number of generic parameters in class definition?

Ex:

public class Test<E,T,U...>

And the exact number of generic parameters to be defined while building the instance of the object.

Answer 1

No, is not possible, what you can do is following:

define the generic BUT allow varargs in the constructor

public class Deyen<T, G, M> {

    private final T typo;
    private final G typo22;
    private final M[] typo3;

    public Deyen(T typo, G typo22, M... typo3) {
        this.typo = typo;
        this.typo22 = typo22;
        this.typo3 = typo3;
    }
}

explicit defining vararg when defining the class itself is not bringing forward the compiler...

Answer 2

Apparently you want to be able to make Test take multiple parameters of different types in the form of varargs.

VarArgs are actually being passed as an Array but you can't have an array with different types of objects in it.

However, Can't we instead take a single parameter and that parameter type holds each of the individual "parameters" that needs to be used.

class TypedInstance<T>{
   Class<T> type;
   T instance;
}

Or

Different classes for each set of parameters you want to use. Then just pass that class as a param.

 class MultiTypedInstanceType1<T, R>{
    public R doSomething(T t){ .... }
}

 class MultiTypedInstanceType2<T, R, P>{
    public R doSomething(T t, P p){ .... }
}

Answer 3

In java it seems not possible to define overloads of type signatures, but in C# it is possible probably because of type expansion . Maybe this is an option...

class Test<A,B> { }
class Test<A> { }

public class Program
{
    public static void Main()
    {
        var one = new Test<string>();
        var two = new Test<string, int>();
    }
}

Here you overload the signature of the type Test to take either one or two type parameters the same way you would do with method overloads. Here is a fiddle for that

Unfortunately you would have to create several types for all your variants instead of defining it via variable argument lists.