Examlab generics question

[ankur trapasiya]

abstract class ABS<K extends Number>
{
//	public abstract <K> K useMe(Object k); // understood ..
	public abstract <K> ABS<? extends Number> useMe(ABS<? super K> k); //1 
	public abstract <K> ABS<? super Number> useMe(ABS<? extends K> k); //2
//	public abstract <K> ABS<K> useMe(ABS<K> k);  // understood ..
}

1 and 2 this both should not work because K can be anything here....

can anyone please explain??? because there is no explanation is given in examlab regarding this too...

[Ankit Garg]

you need to look at it differently. K cannot be anything when the method is called. In fact K will be resolved based upon the method call itself. Lets take a simple example

class Abc<K extends Number> {
   public void <M> method(Abc<M> abc) {
   }
}

Here too M can be anything, but since we can't instantiate class Abc with anything except for Number or its sub-types, we know that M will actually resolve to Number or its sub-type.

method(new Abc<String>());  //won't compile
method(new Abc<Integer>());  //fine, M resolves to Integer

[ankur trapasiya]

Ankit....!!! I code what you said ..but it is not working ....

import java.util.*;
class Gen1<K extends Number>
{
	public <T> void doSomething(Gen1<T> x)
	{
		System.out.println("here in this");
	}
}
public class GenericTest2
{
	public static void main(String[] args)
	{
		Gen1<Integer> g=new Gen1<Integer>();
		g.doSomething(new Gen1<Integer>());
	}
}

D:\java\scjp\SCJPEXAM\Collections\GenericsX>javac GenericTest2.java
GenericTest2.java:4: type parameter T is not within its bound
public <T> void doSomething(Gen1<T> x)
^
1 error



this error comes when i try to compile this code...

[Ankit Garg]

Hmm you are right it doesn't work, I forgot that M/T can be resolved without relying on the parameters passed to the method. Like if there is a method like this

class GenericExp {
static <T> void method(T obj) {}
}

Now T can resolve depending upon the object passed to the method and also I can explicitly specify the type of T

GenericExp.<String>method(null);  //T evaluates to String

So in this case even though I passed null to the method, I explicitly told the compiler during the method call that T is String. This is why the example I gave you doesn't work as T in that case can be explicitly set to a value which is out of bounds for class Gen1. I'm not going to lie to you, but I'm also confused why those 2 statements compile fine (maybe its due to sleep deprivation), its weird behavior...

[Devaka Cooray]

ankur trapasiya wrote:because there is no explanation is given in examlab regarding this too...

Grr...
Ankur, can you let me know the question number of this?

[Seema Kekre]

Ankur, I am having a difficult time understanding Generics as well. I will give my best shot at explaining this:

  abstract class ABS<K extends Number>  
  {  
      public abstract <K> K useMe(Object k); // understood ..  
      public abstract <K> ABS<? extends Number> useMe(ABS<? super K> k); //1   
      public abstract <K> ABS<? super Number> useMe(ABS<? extends K> k); //2  
      public abstract <K> ABS<K> useMe(ABS<K> k);  // 3  
  }  

1 should never compile anyway because ABS<? super Number> means ABS<Object> is valid, which is untrue. So even if K is Number or its subtype, this method is not applicable.
Similarly Line 3 will never compile because K can be anything and it has to be K extends Number. Hence it is not allowed.

But, one conflict between 1,2 & 3 is, what happens when you say

 ABS<Number> a = new SubClassABS<Number>();
a.useMe(a);//4

Now method on Line 1 for SubClassABS can be interpreted as

 public <Number> ABS<? extends Number> useMe(ABS<? super Number> k); //1 

Line 2 can be

 public <Number> ABS<? super Number> useMe(ABS<? extends Number> k); //2 

Line 3 can be

 public <Number> ABS<Number> useMe(ABS<Number> k); //3 

However your a in a.useMe(a)(Line 4) matches ABS<? super Number>(Line 1) as well as ABS<? extends Number>(Line 2) as well as ABS<Number>(Line 3)
So all 3 methods are applicable. The compiler will not know which one to choose at runtime. Now if you comment out 1 and 3, 2 will compile without any issue. 2 compiles because there is a chance that <K> defined in the method is Number.

Experts please comment.
Seema.

[ankur trapasiya]

Too much confused in generic methods ...
Thanks all for reply....

@Devaka : question number is 57 from Diagnostic exam...

[Adrabi Abderrahim]

hello,
very nice explanation,

I try my version ,
In other word is easy to check it, you can in first just remove all generics and compare methods signatures, euh how?

first you've :

      public abstract <K> ABS<? extends Number> useMe(ABS<? super K> k); //1      
      public abstract <K> ABS<? super Number> useMe(ABS<? extends K> k); //2 

after removing generics:

    public abstract ABS useMe(ABS k); //1    
    public abstract ABS useMe(ABS k); //2 

now what, you see? can be compiled? no, some signature!
another example:

	public void method(List<String> l){}
	public void method(List<List<List<List<Double>>>> l){}