Generic class declarations

[King Lung Chiu]

Hi everyone,

I was wondering, does anyone know if there's a difference between the following two declarations?

// Subclasses are simple extensions of the raw Fruit class
abstract class Fruit<E extends Fruit> implements Comparable<E> {
   ...
   public int compareTo(E that) { ... }
}
 
// Subclasses are extensions of the parameterized Fruit class
abstract class Fruit<E extends Fruit<E>> implements Comparable<E>  {
   ...
   public int compareTo(E that) { ... }
}

Both seem to compile and run fine. But I was wondering, is the 2nd more semantically correct than the 1st?

And what am I trying to do here, I hear you ask? I'm trying to create various types of fruits - Apples, Oranges - that can only compare with themselves. The comparison logic is the same for all fruits, so I'm placing that logic in the superclass Fruit and using generics to bind compareTo() to the correct subclass. This avoids duplicating the same comparison code in all subclasses. The rest of the code looks like this (compiles and runs correctly):

class Apple extends Fruit<Apple> {
   public Apple(int size) { super("Apple", size); }
}
 
class Orange extends Fruit<Orange> {
   public Orange(int size) { super("Orange", size); }
}
 
// inside main
List<Apple> apples = Arrays.asList(new Apple(1), new Apple(2));
List<Orange> oranges = Arrays.asList(new Orange(3), new Orange(4));
List<Fruit> fruits = new ArrayList<Fruit>();
fruits.addAll(apples);
fruits.addAll(oranges);
           
Collections.max(apples);
Collections.max(oranges);
 
// compiler throws unchecked warnings as expected
Collections.max(fruits);
 
// compiling fails as expected
apples.get(0).compareTo(oranges.get(0));
 

I'm using the same Apple and Orange definitions for both types of Fruit header declarations.

Since Apple extends Fruit<Apple> and Orange extends Fruit<Orange>, I thought the 2nd Fruit declaration (using <E extends Fruit<E>> would be the correct one. However, the code compiles and runs fine with the 1st Fruit declaration too (using <E extends Fruit> , so that got me wondering if there really is any difference between the two.

All comments are welcome, cheers!

King

PS. Yes, for those eagle eyes, this is a modified example from Naftalin and Wadler's "Java Generics and Collections", combined with ideas from Java 5's Enum implementation :-)

[King Lung Chiu]

... and please ignore those winking icons - they're supposed to be closing brackets - not sure how they got there ...

cheers!

[Campbell Ritchie]

Welcome to the Ranch.

To get rid of the you want to tick the box on the bottom left labelled "disable smilies."

Why are you parameterising Fruit in the first place? I can see no benefit in writing

public class Apple extends Fruit<Apple>

over

public class Apple extends Fruit

.

And surely it's

public class Fruit implements Comparable<Fruit>

?

[edit]Minor spelling corrections[/edit]
[ February 17, 2008: Message edited by: Campbell Ritchie ]

[King Lung Chiu]

Hi Campbell,

Thanks for the reply.

Why are you parameterising Fruit in the first place? I can see no benefit in writing

public class Apple extends Fruit<Apple>

over

public class Apple extends Fruit

Because:

(1) I only want a specific Fruit subclass to be comparable to themselves, and not to any other different subclass. eg. I don't want to allow an Apple to be comparable to an orange.

(2) I don't want to duplicate the compareTo() code in all Fruit subclasses, so I'm writing it once only in the Fruit superclass, and using generics to bind it to a specific subclass when required. Please look at the compareTo() definition in my first post again, it'll make more sense.

And surely it's

public class Fruit implements Comparable<Fruit>

Yes, if you want to use compareTo(Fruit), ie. allow all Fruits to be comparable to each other, even allow an Apple to be comparable to an Orange.

No, if you don't want to use compareTo(Fruit), but rather compareTo(A-Specific-Fruit-Subclass), ie. only allow a Fruit subclass to be compared to the same Fruit subclass.

And I'm trying to design for the 2nd case.

I appreciate the alternative suggestions, but I've already considered them and they're not suitable for what I need. So please assume that I have good reasons to use Apple extends Fruit<Apple> and [I]Orange extends Fruit<Orange>[I], and that given such case, whether there is any technical or semantic differences between the following Fruit header declarations (both have the exact same class bodies, and both compile and run fine with the same Apple and Orange definitions show above):

abstract class Fruit<E extends Fruit> implements Comparable<E> {
   ...
   public int compareTo(E that) { ... }
}
 
abstract class Fruit<E extends Fruit<E>> implements Comparable<E>  {
   ...
   public int compareTo(E that) { ... }
}

Thanks again.

King

[Garrett Rowe]

I'm no expert in generics, but both seem to be equivalent. And they both fail in some interesting ways.

public class Fruit<E extends Fruit<E>> implements Comparable<E>
{
   public int compareTo(E other)
   {
      return 0;
   }
 
   public static void main(String[] args)
   {
      Apple a1 = new Apple();
      Apple a2 = new Apple();
      int compApps = a1.compareTo(a2);//Passes compilation
 
      Pear p = new Pear();
      int compAppAndPear = a1.compareTo(p); //Compilation error
 
      Fruit<Apple> f1 = new Apple();
 
      int compFruitAndApple = f1.compareTo(a1); //Passes compilation
      int compAppleAndFruit = a1.compareTo(f1); //Compilation error
 
      Fruit<Apple> f2 = new Apple();
      int compFruits = f1.compareTo(f2); //Compilation error
 
   }
}
 
class Apple extends Fruit<Apple>
{
}
 
class Pear extends Fruit<Pear>
{
}

[ February 17, 2008: Message edited by: Garrett Rowe ]

[King Lung Chiu]

Hi Garrett,

Thanks a lot for the reply. And thanks for the interesting examples.

I think I can explain why they're like that (my understanding):

Fruit<Apple> f1 = new Apple();
int compFruitAndApple = f1.compareTo(a1); //Passes compilation

Here, f1 is Fruit<Apple>, so its compareTo() takes an Apple, thus it compiles fine.

int compAppleAndFruit = a1.compareTo(f1); //Compilation error

Here, since f1 is a Fruit<Apple> rather than an Apple, and since a1.compareTo() takes an Apple, compilation fails. Though it's safe to cast f1 back into an Apple, if required, since it references an Apple.

 
Fruit<Apple> f2 = new Apple();
int compFruits = f1.compareTo(f2); //Compilation error

Here, both f1 and f2 are Fruit<Apple>s, and because of the parameterisation, they both use compareTo(Apple), rather than compareTo(Fruit<Apple>), thus the compilation fails.

And I think you're right that Fruit<E extends Fruit> and Fruit<E extends Fruit<E>> are equivalent ... at least according to the 1.6.0_01 compiler I'm using, they both give the same errors with your examples.

thanks again, cheers,

King