how compiler infers the type in java generics

Question

I have generic method which looks something like this.

public static <T> T addAndReturn(T element, Collection<T> collection){
    collection.add(element);
    return element;
}

When I call

String stringElement = "stringElement";
List<Object> objectList = new ArrayList<Object>();
Object theElement = addAndReturn(stringElement, objectList);

It infers the type as object.

When I call

Object objectElement = new Object();
List<String> stringList = new ArrayList<String>();
Object theElement = addAndReturn(objectElement, stringList);

the compiler reports error.

What are the rules behind this?

A full explanation of "the rules behind [generics]" is rather broad for SO ... Suggest you check out the [Java Tutorial](http://docs.oracle.com/javase/tutorial/java/generics/) for an overview, or [Angelika Langer's excellent FAQ](http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html) for more in-depth coverage. — dcsohl, Apr 21 '16 at 18:27
Also see [*"Is List a subclass of List?"*](http://stackoverflow.com/q/2745265/2891664) We can turn a `String` in to an `Object` but we can't turn a `List` in to a `List — Radiodef, Apr 21 '16 at 18:29

score 4 · Accepted Answer · answered Apr 21 '16 at 18:25

4

In the first case, you are passing a List<Object> to the Collection<T> so T must be an Object type. A String stringElement is a sub-class of Object so this is allowed.

In the second case, you are passing a List<String> to the Collection<T> so T can only be String. As Object objectElement is not a String type this is not allowed.

You can't add an Object to a List<String> which seems reasonable.

answered Apr 21 '16 at 18:25

Peter Lawrey

525,659
79
751
1,130

that helps.So the last parameter in the function will always have higher preference? – starkk92 Apr 21 '16 at 18:33
1

@starkk92 the most restrictive parameter will dominate. – Peter Lawrey Apr 21 '16 at 18:34

score 1 · Answer 2 · answered Apr 21 '16 at 18:27

Generics can be difficult to grasp, I recommend you read up on it carefully.

In your example, you have a type T which can be any one type. This type is "generic" in that it conforms to what type is put into it. So, when you pass an ArrayList<String> as the Collection<T> parameter, T becomes String in that instance. Therefore, the return type of the method becomes String.

score 1 · Answer 3 · answered Apr 21 '16 at 18:33

Generics work on principle of Type inference. The compiler checks the type which from the generic class. Once the type is determined the compiler performs compile time type checking to make sure that all the type which are passed are correct. Generics also has type erasure at runtime but that is a different thing and we can skip it for this discussion.

To apply this principle on your questions: In the first case you are creating an object of type String which can be easily added to a ArrayList of type Object as String is a sub class of Object.

For the second example you are now doing the exact opposite. You are trying to save a Object class object in a reference of String class which is not allowed.

Thus if you notice the rules are exactly same even as that of a non generic code.

how compiler infers the type in java generics

3 Answers3