Java泛型：仅通用返回类型和通用返回类型和参数类型

Question

To start with an example,

public static <T> T method(T str){
    return (T)str;
}
// T is deduced to be a String
// This fails at compile time
Integer integer = method("Trial");
//Object obj = method("Trial"); // Old example

and,

public static <T> T method(String str){
    return (T)str;
}
// What type does T gets deduced to in this case?
// This compiles but gives an error at run-time.
Integer integer = method("Trial");
//Object obj = method("Trial"); // Old example

Both code snippets compile fine. Which type does T get deduced to in the second example?

Answer 1

Non specified Generic Type is considered as Object so returned type is correct in both cases. So which method is used ?
In fact, the most precise matching type will be accepted first. In your case method(String str) as "Trial" is a String .

// Will rename for understanding
// method(T str) => method1
// method(String str) => method2 
public static <T> T method1(T str){
    return (T)str;
}
public static <T> T method2(String str){
    return (T)str;
}
// This is your implementation
Object obj = <Object> //as undefined
    method2("Trial"); // as mentionned above

// BUT
Object obj = <Object> // as undefined
    method1(1); // as 1 is an int upperbounded to Object

// AND
Object obj = <String> 
    method2("Trial");
Object obj = <String>
    method(1); // will not compile

You should check this post for more details about overloading priorities

Answer 2

I am having a bit of a hard time following the question but anyways.

In your first example the return type is determined (inferred) by the passed in type of the method parameter (ie String in that case). Consider the following example:

public static <T> T something(T something) {
    return something;
}

And two calling examples:

String something = something("string");
Integer someOther = something("something");

The first one works OK but the second produces an error as the dynamically inferred return type is String whereas we attempt to store it an Integer variable.

Now the reason why this works fine when you assign both values to an Object variable is -- as mentioned above -- the fact that this is the upper bound of both String and Integer . In fact in you take a look a the disassembled class file using javap you'll see that your method's signature looks like this:

public static <T extends java.lang.Object> T something(T)

Note that all the above will effectively end up being Object types after compilation due to Java's type erasure.

On another sidenote, your example also casts the passed in parameter to T which is redundant as this is handled by compiler's ability to infer types.

I suggest you take a look at the following:

https://www.baeldung.com/java-type-erasure https://www.tutorialspoint.com/java_generics/java_generics_type_inference.htm

Now let's take into consideration your second example:

In that one, T will effectively and up to an Object type -- as I mentioned above. This is still the upper bound for the method but there is a caveat here. This method is wrong as it accepts the String object and attempts to cast it (wrong again) to the inferred type.

So for example I can do this (which compiles OK) but produces a ClassCastException on runtime:

public static <T> T something2(String something) {
    return (T) something;
}

and this call:

Integer somethingOther = something2("sas");

Now as mentioned above the reason why this works when assigning to Object is that it is the parent classes of String and everything else.

Answer 3

The first function in your case has both data type of parameter and return type of function as T , which means both of them can be of any type. They can be string, integer, float, character, array, or anything else. The scope of this T type is restricted to this particular function only.

The second function has a data type of parameter as String , while the return type is T , meaning that only String type of values can be passed to this function.

For example,

public static <T> T func1 (T var)
{
     return var;
}

The above function can have a = func1("String") or b = func1(2) or anything else. a will be of type String , and b will be of type int . On the other hand,

public static <T> T func2 (String var)
{
     return var;
}

will return an error on func2(2) .

Refer to Oracle Docs to get a detailed insight into Generic Methods.

Edit to Comment : When a function is being called, the Java compiler automatically infers the type of the parameter from the method arguments. When I invoke func1() in my example, I write func1("ABC") . The Java compiler is intelligent enough to now understand the T type of the argument is String. Similarly, I return a String type from func1 , so the compiler will now know that the return type has to be String.

You can also go through https://docs.oracle.com/javase/tutorial/java/generics/genTypeInference.html to study more.