Convert Generic Types to Objects

I am writing a transformer to convert String input to output of custom type. Here's how the interface looks like:

public interface Transformer<T> {
	public T transform(String input);
}

There will multiple implementations of it (i.e. IntegerTransformer, ByteTransformer etc). I have written a factory that returns these transformers, e.g.:

public class TransformerFactory {
    public <T> Transformer<T> getTransformer(final SomeEnum enum, final T type) {
		switch(enum) {
		case FOO:
			return new IntegerTransformer();
		case BAR:
			return new ByteTransformer();
			default:
				throw new Exception("blah");
		}
	}
}

In my main class, I am doing this:

factory.getTransformer(foo, Integer.class).transform(input);

This results in the following error:

Type mismatch: cannot convert from Class<Integer> to Integer

So, I somehow need to convert Type literal to Object. Is there any way I can do that without modifying the generic structure of interface and factory?

The signature of getTransformer(final SomeEnum enum, final T type) expects an actual objet of type T. What you want is pass a instance of class, so it should be:
getTransformer(final SomeEnum enum, final Class<T> type)

In addition, since Java 8 there is no need for declaring such simple interfaces. Using the generic Function<String,T> would serve you perfectly.

TL;DR: Not trying to snipe @MAnouti's points that you've earmarked for him/her. But for the sake of completeness, OP, I wanted to share what I observed in my attempt to reproduce your error.

> „This results in the following error:“
>
> Type mismatch: cannot convert from Class<Integer> to Integer

The original example code in your question fails to compile (as confirmed by my failed attempt to reproduce the same error) with these different compilation errors&hellip;

...
incompatible types: IntegerTransformer cannot be converted to Transformer<T>
...
incompatible types: ByteTransformer cannot be converted to Transformer<T>
...

&hellip;Notice those are not the same as the error you reported in your question.

And even if you did follow the advice of the other answers/comments and replaced T with Class<T> as the second formal parameter of your method, you would still get the above cannot be converted to Transformer<T> compilation errors.

> „&hellip;Is there any way I can do that without modifying the generic structure of interface and factory?“

I have confirmed by a simple experiment that this meets that criteria. And it successfully compiles and runs as expected&hellip;

    public < T, U extends Transformer< T > > U getTransformer( SomeEnum eNum, Class< T > type ){ 
    
    switch( eNum ){ 
        case FOO:
            return (U)new IntegerTransformer( );
        case BAR:
            return (U)new ByteTransformer( );
        default:
            throw new RuntimeException( "Detected Decepticons Among Us!" );
    }
}

&hellip;It fixes both the error you reported in your question, and the cannot be converted to Transformer<T> errors you'd get if the only thing you changed was the parameter to Class<T>.