Generics question

[Mark Uppeteer]

Hi guys,

this gives a compiler fault at

gp.aMethod(new Integer(5));

any idea whats the explanation ?
I know its a little bit tricky,but Integer extends number so why can't I pass it into the method ?

public class Thursday{
 
/**
 * @param args
 */
public static void main(String[] args) {
GenericP<? extends Number> gp = new GenericP<Integer>();
gp.aMethod(new Integer(5));
}
}
 
class GenericP<T>{
public T aMethod(T t){
return t;
}
}
 

thanks!


regards,
Mark

[Burkhard Hassel]

Mark wrote:

Integer extends number

Yes. But there is no polymorphy with generic types. But this isn't the problem here. It's because the type is unknown.
Even this will not compile:

class Thirstday {
public static void main(String[] args) {
GenericP<? extends Number> gp = new GenericP<Integer>();
[B]Number n = null;[/B]
gp.aMethod(n);  //  <<<<< no compile!
}
}
 
class GenericP<T> {
public T aMethod(T t) {
return t;
}
}

Whereas this will compile and print "null":

class FryingDay {
public static void main(String[] args) {
GenericP<? extends Number> gp = new GenericP<Integer>();
// Number n = null;
System.out.println(gp.aMethod(null));
}
}
 
class GenericP<T> {
public T aMethod(T t) {
return t;
}
}

Yours,
Bu.

[ December 14, 2006: Message edited by: Burkhard Hassel ]
[ December 14, 2006: Message edited by: Burkhard Hassel ]

[Sanjeev Singh]

GenericP<? extends Number> gp = new GenericP<Integer>();

The following declaration is perfectly true which says that any collection that is a subtype of Number and typed for <Number> or any of its subclass is the right candidate to refer to.

But using this signature one can also pass(we dont know what the method can do with the passed collection..it can alter it) Short,Long,Float and so on.. and will break the collection,so as long as we dont add any object to this collection it is perfectily true.

To change the program to be a perfect one we need to change it as

GenericP<? super Integer> gp = new GenericP<Integer>();

In this case one can pass Integer only ,not the Short,Byte,Long...not Object too.However the polymorphic type gp refers to some other collection suppose typed for Object then also it is perfectly legal to add object of Object in it.. like

gp=new GenericP<Object>();
gp.aMethod(new Integer());

[ December 14, 2006: Message edited by: Sanjeev Kumar Singh ]

[David Grindley]

Hi Mark

Here are two code samples similar to yours that do compile. (Well at least they do on my box!)

Code sample 1
This shows how to make a generic class more specific.

public class Thursday{
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        GenericP<Integer> gp = new GenericP<Integer>();
        gp.aMethod(new Integer(5));
    }
}
 
class GenericP<T extends Number>{
    public T aMethod(T t){
System.out.println(t.byteValue());
        return t;
    }
}
    

Code Sample 2
Shows one example of how to use polymorphism with Generics. To quote from K & B in the two minute drill for Generics(Objective 6.4) "Polymorphic assignments applies only to the base type not the generic type parameter."

  public class Thursday{
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        GenericP<Integer> gp = new DerGeneric<Integer>();
        gp.aMethod(new Integer(5));
    }
}
 
class GenericP<T>{
    public T aMethod(T t){
        return t;
    }
}
 
class DerGeneric<T> extends GenericP<T> {
}
  

All the best

Dave

[Ahmed Khan Mohammed]

The declaration
GenericP<? extends Number> gp
says that anything can go in this gp which passes the "is a" test for Number. You created the class GenericP to hold only Integer (new GenericP<Integer> , if the method call gp.aMethod would have succeeded then anything which is a Number could be passed to that method which is supposed to accept only Integer and all your type safety will be lost, to avoid such situation the above code is illegal. Following is just a variation of the declaration
GenericP<? super Number> gp = new GenericP<Number>();
gp.aMethod(new Integer(5));
gp.aMethod(new Double(5));
in which case your type safety is assured and the compiler is also happy.

Hope I am clear.

[Mark Uppeteer]

Hi all,
thanks for the answers!
The goal of my answer was to try to understand how it works.
I know how to write a regular generic class, but since you can do all this strange stuff, I'm trying to understand to point of why you can do it.

to Sanjeev Kumar Singh: this problem has nothing todo with collections
to Burkhard Hassel: yes, apperantly it is notpossible to create an argument that fullfills the need of the method. Null avoids the problem a bit.
to David Grindley : yes, those are the cases that generics work normal
to Ahmed Khan Mohammed : I like your explanation , but it doesn't compile either.

    
public class Thursday{
 
/**
 * @param args
 */
public static void main(String[] args) {
GenericP<? extends Number> gp = new GenericP<Number>();
gp.aMethod(new Integer(5));//compile error
}
}
 
class GenericP<T>{
public T aMethod(T t){
return t;
}
}

regards,
Mark