Mock Exam doubt Generics

[Jagdev Singh]

Hi All,
Following is the code

public class Test {
public <T extends Comparable> T findLarger(T x, T y) {
 if(x.compareTo(y) > 0) {
 return x;
 } else {
 return y;
 }
 }
public static void main(String [] as) {
Test t = new Test();
//insert code here

Following are the code fragments which will compile without errors when inserted at //insert code here

A. Object x = t.findLarger(123, “456”);
B. int x = t.findLarger(123, new Double(456));
C. int x = t.findLarger(123, new Integer(456));
D. int x = (int) t.findLarger(new Double(123), new Double(456));

I tested this code and observed that A and C are compiling successfully.

Can anyone please explain this strange behaviour of code.

Thanks in advance.

[jamil lusa]

hi,

C is correct, i think is rational. moreover, B and D is incorrect is also understandable.

But A is correct a bit confuse me. Could you try to change the string "456" to "abc"?

I guess, in Integer class, it accepts string argument which is like this:

Integer(String s) 

so maybe it automatically turn into Integer??

Need explanation from pro....

[Will Myers]

A) works because the return type is either going to be an Integer or a String which are both subtypes of Object
B) fails because you can't cast a Double to an int
C) works because you can cast an Integer to an int
D) fails for the same reason as B

This is not a Generics question but a question of casting...sneaky eh?

[John Schubert]

Yes, it compiles, but does A run without Exceptions? (Like when we put in a TreeSet objects of different types)

EDIT:
Just tested, no it doesn't:

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer

[Will Myers]

The programmer exam is quite specific between compiler and runtime errors - as we all know just because something compiles doesn't mean it is right or will run

[Puneet Chadha]

Not quite clear guys
what class is 'T' determined as in the call of option A. ?

[Will Myers]

Object x = t.findLarger(123, "456");

is passing an int (123) and a String ("456") to the findLarger method, this is converted to an Integer and a String automatically by the compiler (AutoBoxing), as both Integer and String implement the Comparable interface this is fine and the method returns whichever of the 2 is appropriate depending on the implementation of Comparable (the compareTo part is where it will fail with the ClassCastException when it is run but the compiler doesn't know this)

if you run this code you get the following:

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
	at java.lang.Integer.compareTo(Unknown Source)
	at test.Test.findLarger(Test.java:5)
	at test.Test.main(Test.java:13)

and this is because the compareTo implementation of Integer is:

public int compareTo(Integer anotherInteger) {
	int thisVal = this.value;
	int anotherVal = anotherInteger.value;
	return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
    }

and clearly you can't cast a String to an Integer

[Matthew Brown]

Well, looking at it, in case A, T has got to be supertype of Integer and String, subject to the restriction that T is a subtype of Comparable.

I think there's only one possibility here: T is Comparable.

[Matthew Brown]

By the way, I think the way to turn your runtime exception into a compile-time error is to declare it like this:

public <T extends Comparable<? super T>> T findLarger(T x, T y) {...

Because Integer implements Comparable<Integer>, and String implements Comparable<String>, option A will no longer compile because they can't be compared with each other. The problem with the example given is that's it's partly generic, but it hasn't gone all the way.

[Jagdev Singh]

Hi,
Thanks all for responces , to understand the option D for casting use the code given below.

public class Cast {
 public static void main(String [] a){
   Double d = new Double(6.7);
   int i = (int)d;
   System.out.println(i);
 }
}

It gives following error.

Cast.java:4: inconvertible types
found   : java.lang.Double
required: int
   int i = (int)d;
                ^

This is an tricky casting question.

[Rajbal Balan]

Matthew Brown wrote:By the way, I think the way to turn your runtime exception into a compile-time error is to declare it like this:

public <T extends Comparable<? super T>> T findLarger(T x, T y) {...

Because Integer implements Comparable<Integer>, and String implements Comparable<String>, option A will no longer compile because they can't be compared with each other. The problem with the example given is that's it's partly generic, but it hasn't gone all the way.

Hi,

Could you please explain this in a little more detail how this declaration would help the compiler to catch the Integer-String comparison, preferable plugging in Integer/String into the declaration.

TIA.