Java Generics -> Function return type

Question

I have a situation like this:

I have a class which looks like:

public class TestClass<T> {
   // class body here...
}

And I have a method that looks like this:

public class AnotherTestClass<K> {
     private TestClass<K> testClass;

     public AnotherTestClass(TestClass<K> testClass) {
         this.testClass = testClass;
     }

     public K testMethod() {
         //call methods on param object and pass a value of the same type as testClass.
         K returnVal = this.testClass.doSomething();
         return returnVal;
     }
}

Now I have a factory method which returns an object of type TestClass<?>

public TestClass<?> sampleFactory(int i) {
       if( i==1 ) 
           return new TestClass<Integer>();
       if( i==2 ) 
           return new TestClass<Double>();
       if( i==3 ) 
           return new TestClass<String>();
}

But I cant use that method to pass parameter to my testMethod. Whats the solution for this?

Currently I am writing if else chain blocks to get correct instance. I know its not correct as its impractical to write if else blocks when there are multiple parameters like the one above.

Please suggest an elegant way for this.

EDIT: Sample usage:

package my;

import java.util.ArrayList;
import java.util.List;

public class GenericsSpike {
    public static void main( String[] args ) {
        TestClass1< ? > tc1 = new TestClass1<Integer>( 123 );
        TestClass2< ? > tc2 = new TestClass2<Integer>( 123 );
        AnotherTestClass< ? > atc = new AnotherTestClass<Integer>( tc1, tc2 );
        atc.testMethod();
    }
}

class TestClass1<T> {
    private T value;

    TestClass1( T val ) {
        value = val;
    }

    // class body here...

    public T getValue() {
        return value;
    }
}

class TestClass2<T> {
    private T value;

    TestClass2( T val ) {
        value = val;
    }

    // class body here...

    public T getValue() {
        return value;
    }
}

class AnotherTestClass<K> {
    public TestClass1<K> testClass1, testClass2;

    public AnotherTestClass( TestClass1<K> testClass, TestClass2<K> testClass2 ) {
        this.testClass1 = testClass;
    }

    public K testMethod() {
        //Any logic can come here.
        System.out.println( testClass1.getValue() );
        System.out.println( testClass2.getValue() );
        return testClass1.getValue();
    }
}

In this case, if tc1 and tc2 are coming from a factory which creates these objects, I want to know whats the decent way to create instance of AnotherClass

Answer 1

Your problem is with this method:

public TestClass<?> sampleFactory(int i) {

The ? wildcard type means "some type, but I don't know what". So you can get a value of type TestClass<?>, but it's not useful to you, because you can't meaningfully interact with the type ? -- you can't create values of type ? (except for null) and you can't call methods on type ? (except methods of java.lang.Object).

What you really want is something like:

public <T> TestClass<T> sampleFactory(TypeToken<T> typeToken) {

That is, if you want your factory to give you back values parameterized by different types, you need to give it something that tells it what type you want. Unfortunately, int isn't enough -- you may know that i==1 means the type will be Integer, but the compiler doesn't know that.

Your description of your problem is a bit too vague for me to understand what you're really trying to achieve, but my guess is that what you really need is either something like super type tokens or maybe something like Guava's ClassToInstanceMap.

Answer 2

One possible solution is to use raw AnotherTestClass type

public class A {
    public static void main(String[] args) {
        TestClass<?> tc = new TestClass<Integer>();
        AnotherTestClass atc = new AnotherTestClass();
        atc.testMethod(tc);
    }
}

class TestClass<T> {

// class body here...

}

class AnotherTestClass<K> {

    public void testMethod(TestClass<K> param) {
    }
}

compiles fine. But it's not good idea to use raw types in general case