Type inference in generic mehods

[Florin Florentin]

I would like to ask a question about type inference.
In the following code, why the Collection type must be of a type which is a supertype of the first argument ? The next code isn't working, but if i would had a collection of Number or Objcet it would be ok.

 
public class Main {

    static <T> void test(T t1, Collection<T> t2){
          ///
    }

    public static void main(String[] args) {

        Integer c1 = new Integer(22);
        Collection<Double> c2 = new HashSet<Double>();

        test(c1,c2);

    }

}

I thought that in the following code, the type would be inferred to Number, but i guess i am wrong, and i don't understand why. I hope i am clear

[Hunter McMillen]

Try making the type of t1 and the type of the collection t2 the same.

[Florin Florentin]

Of course making the same types will work, i am sure about that. But i was asking why is it not working now, maybe i wasn't very clear

[Ankit Garg]

I'm not completely sure what you are trying to say, but generic types cannot be polymorphic, so you can't do this

ArrayList<Number> list = new ArrayList<Integer>();

This code won't compile as you can't use polymorphic assignment of generic types. In your code too you are passing the method Collection<Double> so if the type T resolves to Number, the code still won't compile...

[Florin Florentin]

I was not talking about polymorphic assignements.
I am asking why

    
 Integer c1 = new Integer(22);  
 Collection<Double> c2 = new HashSet<Double>();  
   
 test(c1,c2); 

is not working, but instead

 
 Integer c1 = new Integer(22);  
 Collection<Number> c2 = new HashSet<Number>();      
 test(c1,c2); 

is working.

I think it's about type inference. I see that if the collection has a supertype type of the Integer, i can call the test method, if it's a subtype, i can't call it. I am asking why is this way?

[Mark Moge]

  
  static <T> void test(T t1, Collection<T> t2){...}
        ...
        Integer c1 = new Integer(22);  // c1 is an Integer type
        Collection<Double> c2 = new HashSet<Double>();  // c2 is a Collection<Double>
        test(c1,c2);// if you put c1 as the first argument than <T> from the method declaration becomes an Integer
        // after that you are trying to put the Collection<Double> into Collection<? super T> (T is still an Integer).
        // The second argument can be the same type or the super type of the first one
        // here it would be Integer, Number or Object type
  

if you dont want to change types of variables than you can try this one

  static <T, N> void test(T t1, Collection<N> t2){  //2 types - T for Integer and N for Double
          ///
    }
    public static void main(String[] args) {
        Integer c1 = new Integer(22);
        Collection<Double> c2 = new HashSet<Double>();
        test(c1,c2);
}

[Florin Florentin]

Thank you Mark.

I am only trying to get how type inference is working, so i don't need suggestions to change the function definition.

I would to ask again why this is working,

    
public class Main {

    static <T> void test(T t1, Collection<T> t2) {
    }

    public static void main(String[] args) {
        
        Integer c1 = new Integer(22);
        Collection<Number> c2 = new ArrayList<Number>();

        test(c1, c2);

    }
}

and this is NOT working :

    

public class Main {

    static <T> void test(T t1, Collection<T> t2) {
    }

    public static void main(String[] args) {

        Number c1 = new Integer(22);
        Collection<Integer> c2 = new ArrayList<Integer>();

        test(c1, c2);

    }
}

[Mark Moge]

I have edited my post so try to read it again.

And the answer is the second argument can be the same type or the super type of the first one.

[Florin Florentin]

Thank you for your quick replies and you help Mark. You helped me .

One more question. In this case,

    

public class Main {

   static <T> void test(T t1,T t2) {}

    public static void main(String[] args) {
 
        Object o1 = new Object();
        String o2 = new String("");

        test(o1, o2);
        
    }

}

the code compiles, so why here the second argument must not be a supertype of the first type? Maybe it's a silly question but i don't know why.

[Nidhi Sar]

Florin Florentin wrote:
One more question.

Good Question Florin. Taking this one step further, why does call to test1() fail in the following code and call to test2() succeed? As per Mark's explanation, both the calls should give a compile error.

public class Stub {

	static <T> void test1(T t1, T t2, Collection<T> t3) {}

	static <T> void test2(T t1, T t2) {}
	

	public static void main(String[] args) {

		String o1 = new String("");
		Double o2 = new Double(0.0);
		Collection<Double> o3 = new HashSet<Double>();

		test1(o1, o2, o3); //Error on this line 
			          //"The method test1(T, T, Collection<T>) is not applicable for the arguments
			          //(String, Double, Collection<Double>)"
		
		test2(o1, o2); //This line compiles and runs fine.
	}
}
    

I don't know the answer, but sure hope that someone else here does!

[Jim Hoglund]

Try this. The compiler error generated shows that 'T' is set to type Object.

public class Today_0809  {
    static <T> T test(T t1, T t2){
         return t1;
    }
    public static void main(String[] args) {
        String str = test(new String("--"), new Object());  
    }
}

Jim ... ...

[Ankit Garg]

Florin as I said above, polymorphic assignments don't work with Generic type collections, so in this code

public class Main {
    static <T> void test(T t1, Collection<T> t2){
          ///
    }
    public static void main(String[] args) {
        Integer c1 = new Integer(22);
        Collection<Double> c2 = new HashSet<Double>();

        test(c1,c2);
    }
}

Here even if T somehow resolves to Number, you can't pass Collection<Double> to Collection<Number>. In case of this code

public class Main {
    static <T> void test(T t1,T t2) {}
    public static void main(String[] args) {
        Object o1 = new Object();
        String o2 = new String("");

        test(o1, o2);      
    }
}

here T will resolve to Object, in this case you can do a polymorphic assignment so o2 is upcasted and passed to test method as an Object...

[Dieter Quickfend]

I hope I am not misunderstanding the question too much, but it appears simple why your original example won't work. An Integer object is simply not the same as a Double Object, and the collection must have Double as a type.

Therefore, if you use T for both an Integer and a Double, the compiler won't know the generic type. It can't be an Integer and a Double at the same time, because even if it were an Object type, it would still be a compiler error, because it's a Double collection. and a Double collection is not an Object collection, so there's no way that can compile.

[Ankit Garg]

Dieter you understood it correctly. This is exactly what I said in my first reply...

[Mark Moge]

Florin Florentin wrote:Thank you for your quick replies and you help Mark. You helped me .

One more question. In this case,

    

public class Main {

   static <T> void test(T t1,T t2) {}

    public static void main(String[] args) {
 
        Object o1 = new Object();
        String o2 = new String("");

        test(o1, o2);
        
    }

}

the code compiles, so why here the second argument must not be a supertype of the first type? Maybe it's a silly question but i don't know why.

If you put the Object type as the first argument then the second one should be the Object type as well. And here you have process called widening conversion. The String type can be widen to Object type (String IS A Object).
--

Jim Hoglund wrote:Try this. The compiler error generated shows that 'T' is set to type Object.

public class Today_0809  {
    static <T> T test(T t1, T t2){
         return t1;
    }
    public static void main(String[] args) {
        String str = test(new String("--"), new Object());  
    }
}

Jim ... ...

And here the first argument is String and the second one is Object. Object IS NOT A String so compilation fails.
After edit:
Arguments type are String and Object so T type is Object. This method returns T t1 and you cannot pass Object (T is Object now) reference to String reference so a compilations fails.

[Florin Florentin]

Ankit Garg is right, he said why when i have a collection the compilation fails : "Here even if T somehow resolves to Number, you can't pass Collection<Double> to Collection<Number> ".

Mark i don't think you are right. You are saying that the order of the argument matters, and the second argument must pass the IS-A test with the first strict type, but you are not right. Following you, the next code would not compile , but it does :

   
public class Main {

   static <T> void test(T t1,T t2) {}

    public static void main(String[] args) {
  
        Integer o1 = new Integer(22);
        String o2 = new String();

        test(o1, o2);
        
    }

}

[Mark Moge]

Ok I was wrong. And after some thinking ... in my opinion it works like this: if you have a generic declaration of a method

 static <T> void test(T t1,T t2) {}     

T from a metod works as T extends superclass of all arguments in method.
So you can put any type as argument:

 static <T> T test(T t1,T t2) {
    return t1;
}     
Number n1 = test(new Integer(8), new Double(8.8)); //ok 
Object o1 = test(new Object(), new String("go")); //ok

[Kevin Kilbane]

Mark Moge wrote:Ok I was wrong. And after some thinking ... in my opinion it works like this: if you have a generic declaration of a method

 static <T> void test(T t1,T t2) {}     

T from a metod works as T extends superclass of all arguments in method.
So you can put any type as argument:

 static <T> T test(T t1,T t2) {
    return t1;
}     
Number n1 = test(new Integer(8), new Double(8.8)); //ok 
Object o1 = test(new Object(), new String("go")); //ok

Excellent question by the way.

I don't know the answer definitively but I think this is how it works. When more than one argument is passed to a method that defines a generic type then the compiler does the following checks:

1. If the arguments are all of the same type then the compiler treats T as that type e.g. if all arguments are Strings then T is treated as a String. Simple.

2. If the arguments are of different types but are in the same class hierarchy then the compiler treats T as the highest in the hierarchy e.g. if the arguments are of types Integer and Number then T is treated as Number.

3. If the arguments are of different types and are NOT in the same class hierarchy then the compiler treats T as Object e.g. if the arguments are of types Integer and String then T is treated as Object by the compiler.

See below:

package com;

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

public class Tester {

	public static void main(String[] args) {

		String s1 = "hello";
		String s2 = "goodbye";
		Integer i1 = new Integer(14);
		Integer i2 = new Integer(16);
		Number n1 = new Byte("4");
		Number n2 = new Float(4.3f);
		List<String> stringList = new ArrayList<String>();
		List<Object> objectList = new ArrayList<Object>();
		List<Number> numberList = new ArrayList<Number>();
		
		doStuff(s1, s2); //compiles, compiler treats T as String as both parameters are Strings
		doStuff(s1, i1); //compiles, compiler treats T as Object as both parameters are different types and not in the same hierarchy
		doStuff(n1, i2); //compiles, compiler treats T as Number as both parameters are different types and are in the same hierarchy
		
		doStuff(s1, s2, stringList); // compiles, compiler treats T as String as all parameters are Strings. Method expects List<String>
		doStuff(s1, i1, objectList); // compiles, compiler treats T as Object as there is a mix of types not in the same hierarchy in the parameters. Method expects List<Object>
		doStuff(s1, i1, numberList); // DOES NOT COMPILE, compiler treats T as Object as there is a mix of type in the parameters. Method expects List<Object> not List<Number>
		doStuff(n1, i1, numberList); // compiles, compiler treats T as Number due to mix of types in the same hierarchy in parameters. Methos expects List<Number>		
	}
	
	public static <T> void doStuff(T t1, T t2) {		
	}
	
	public static <T> void  doStuff(T t1, T t2, List<T> tList) {
	}
}

Note: edited since first posted

[Mark Moge]

Kevin Kilbane wrote:
When the arguments are of the same type, the generic type is that type

true

Kevin Kilbane wrote:
When more than one argument is passed to a method that defines a generic type and those arguments are not all of the same type then the compiler treats the generic type as Object

Not true, because you can write

public static <T> T doStuff(T t1, T t2) { return t1;} //return t1 of T type
...
Integer i1 = new Integer(8);
Double d1 = new Double(8.8);
Number n1 = doStuff(i1,d1); // and compiler treats T as Number - super class of all arguments

[Kevin Kilbane]

yep Mark, you are right - see my edited post and my 3 rules for determining the generic type. does that sound right to you?

[Mark Moge]

Kevin Kilbane wrote:

1. If the arguments are all of the same type then the compiler treats T as that type e.g. if all arguments are Strings then T is treated as a String. Simple.

2. If the arguments are of different types but are in the same class hierarchy then the compiler treats T as the highest in the hierarchy e.g. if the arguments are of types Integer and Number then T is treated as Number.

2.1 If you want to put a generic collection as an argument then it can be a collection with a parameter <T super HighestClassOfArgumentsHierarchy>. In this case Number or Object.

Kevin Kilbane wrote:
3. If the arguments are of different types and are NOT in the same class hierarchy then the compiler treats T as Object e.g. if the arguments are of types Integer and String then T is treated as Object by the compiler.

3.1 If you want to put a generic collection as an argument then it can be only a collection with a parameter <Object>. In this case Object.

The end

[Jim Hoglund]

Excellent discussion . The lesson for me is that generic method declarations
should be used with great care, and probably not like the examples used above.

Jim ... ...