Type mismatch with generics

[Paul Berry]

Me and generics have yet to make peace. For something that *seems* so simple, it has been battle after battle.

I'm trying to make a Comparator to help with a sorting task. Below is a hacked down version of the class which still gives the error.
I'm not understanding why it won't compile. The error message doesn't help, because to me it says "Error ...apple does not equal apple!"
I gave it <T extends String> after having problems with a simple <T>. I figured that it didn't have enough information so I added the constraint. ("extends String" means String or lower in inheritance right?) But still it will not compile if I try to use any String methods on what I believe to be a String. Other attempts just yielded "cannot find symbol" errors. String is in java.lang, so it must be able to find it right? Anyway, any help on this would be great.

Thanks,
Paul

import java.util.Comparator;

class TestComparator<T extends String> implements Comparator<T>
{
    public int compare(T o1, T o2)
    {
        T myVariable = o1.toString();

        return  1;
    }
}

TestComparator.java:7: error: incompatible types
T myVariable = o1.toString();
^
required: T
found: String
where T is a type-variable:
T extends String declared in class TestComparator
1 error

[Paul Clapham]

Let's look at this code:

T myVariable = o1.toString();

The toString() method returns a String. But T is some subclass of String. If you're going to assign an object to a variable of a subtype like that, you have to use a cast.

This is a basic rule of Java which has nothing at all to do with Generics. And Generics doesn't make that rule go away. Here's another example of the rule which you might understand more clearly:

String myVariable = new Object();

String is a subclass of Object, you say, so why can't we do that assignment? Because the thing you assign to a String variable must be a String, or a subclass of String. Object won't do.

It's exactly the same with your Generics code, just obfuscated a bit.

[Jesper de Jong]

Note that class String is final - it is not possible to subclass it. So declaring a type parameter "T extends String" doesn't really make sense - the only type T that can satisfy the restriction is class String itself. This means that you don't need the type parameter at all, you could just as well just use String instead of the type parameter T.

import java.util.Comparator;

class TestComparator implements Comparator<String>
{
    public int compare(String o1, String o2)
    {
        String myVariable = o1.toString();

        return  1;
    }
}

[Paul Berry]

OK guys thank you. I'll have to remember that even though something is obvious to me, the compiler may not have enough information to determine; or guarantee.