Passing Class T to a generic MyClass T 's constructor

Question

I have a class like this:
class MyClass<T> {
    Class<T> theClass;
    MyClass(Class<T> theClass) {
        this.theClass = theClass;
}This would require the following code to instantiate:
MyClass<String> myClass = new MyClass<String>(String.class);Correct? This is the simplest syntax for creating the class? It seems redundant to have to pass the type "String" twice when constructing the class. I understand constructors can have type parameters like methods, but that type parameter doesn't translate the T parameter to the class, so that won't work.
I tried the following solution:
class MyClass<T> {
    Class<T> theClass;
    MyClass(Class<T> theClass) {
        this.theClass = theClass;
    public static MyClass<T> create(Class<T> theClass) {
        return new MyClass<T>(theClass);
}This allows for the syntax:
MyClass<String> myClass = MyClass.create(String.class);Which seems more elegant. Of course, the obvious problem with doing this is that it makes subclassing of MyClass much more difficult. Sometimes I can get away with this workaround, more often I cannot. Have I missed anything?

Answer 1

Let's be real here. We are talking about a single line of code. Not a huge class.
You have to change the one if you change the other. There's no danger of one
getting left behind.I don't agree. The nature of creating a class is that for every class you create, there will be one or more (usually more, sometimes MANY more) users of that class. If it were a class like StringBuffer that is used in a million places, then you are making code less redundant for each one of those use cases, and all you had to do was add a factory method.
You are creating a factory method on you class because of distaste for a
syntactical construct. You don't see how this factory method changes the
design?In a strict sense, yes, it impacts the design inasmuch as adding a method changes the contract of the class. However, I don't see how it makes any practical difference in the design.
Are you going to create this factory method for every class that has this kind of
situation? I imagine someone is going to come along later to maintain the
code and think "what the..?" Yeah, and they'll click on "Go to definition" in their IDE and see the extremely complicated method:
public static <U> create(Class<U> theClass) {
    return new MyClass<U>(theClass);
}If they can't understand that, they don't understand generic code and probably shouldn't be mucking around there anyway.