How to interpret “public T readObjectData(… Class type)” in Java?

Question

I have this Java code.

public  T readObjectData(ByteBuffer buffer, Class type) {
...
T retVal = (T) summaries;
return retVal;

Answer 1

<T> is a parameter class. There is no class named T. You can use this method with any class specified via second method argument named type.

since method is defined as following:

public <T> T readObjectData(ByteBuffer buffer, Class<T> type)

You can call it as written below:

MyClass obj = o.readObjectData(buffer, MyClass.class);

Please pay attention that you do not have to cast return value of readOjectData() to MyClass. Once upon a time, before java 5 this method would be defined as:

public Object readObjectData(ByteBuffer)

and its usage looked like:

MyClass obj = (MyClass)o.readObjectData(buffer);

Since casting may cause ClassCastException this is a bad practice. This was a reason for invention of generics.

Answer 2

The <T> part is declaring a generic type argument T. If you were to omit this part, the compiler would likely complain that the type T doesn't exist.

In this case, T serves as a placeholder for an actual type, which will only be determined when the method is actually called with non-generic type arguments.

public <T> T readObjectData(...
        ^  ^
        |  + Return type
        + Generic type argument

Answer 3

This declares the readObjectData method generic, with one type parameter, T.

public <T> ...

Then the return type is T.

... T readObjectData(...

Without the initial <T>, which is the generic type declaration, the symbol T will be undefined.

In the parameter list, Class<T> type is one of the parameters. Because the return type and this parameter both reference T, this ensures that if you pass in a Class<String>, then it will return a String. If you pass in a Class<Double>, then it will return a Double.

To pass in the parameter, pass in any Class object, e.g. String.class.

Answer 4

You are probably confused by a similar and more common declaration:

class MyClass<T> {
   private  T myMethod(T a){
       return  a;
   }
}

In above case, there is no need for "<T>" after private ( private <T> T myMethod(T a) )

because the T it's using is the same than the one defined in the class MyClass<T>

Even more, if you write

class MyClass<T> {
   private <T> T myMethod(T a){
       return  a;
   }
}

then the meaning is that the myMethod return type is (potentially) different than the MyClass type. As if you wrote this instead:

class MyClass<T1> {
   private <T2> T2 myMethod(T2 a){
       return  a;
   }
}

Credits: Took the example from "Kanagavelu Sugumar"'s longer answer to How to use Class<T> in Java?