Comparable and generics

[rakesh sugirtharaj]

Hi all,

How is it logically correct to compare a sub class with a super class? I read in a book that -

It isn�t necessary that T be comparable to exactly itself. All that�s required is that T be comparable to one of its supertypes.

and that is why comparable is defined as
Comparable<? super T>

Thanks

[Joe Ess]

Originally posted by rakesh sugirtharaj:
How is it logically correct to compare a sub class with a super class?

Would it make sense to compare two different ways to represent the same thing, like a date on the Gregorian Calendar to a date on the Julian Calendar? I'd think so. Presumably they'd have the same base class and that would indicate the relationship between the derived classes: they both represent time.

Originally posted by rakesh sugirtharaj:

Comparable<? super T>

I don't see it. Perhaps your book does that to drive the point home?

[rakesh sugirtharaj]

I actually found that statement in a pdf download from Sun site.
Generics tutorial by Gilad Bracha.

[Daniel Chemko]

You sparked my interest in what the differences would really be, so I wrote a test app to play around with the concept. Anywhere the file doesn't compile, we can see the limitations of each type of passing in a comparator

import java.util.Comparator;
 
public class FunComparator
{
   public static class LessThanWidgetComparator implements Comparator<LessThanWidget>
   {
      public int compare(LessThanWidget o1, LessThanWidget o2)
      {
         return -1;
      }
   }
   public static class WidgetSuperComparator implements Comparator<WidgetSuper>
   {
      public int compare(WidgetSuper o1, WidgetSuper o2)
      {
         return 0;
      }
   }
   public static class WidgetSuper1Comparator implements Comparator<WidgetSuper1>
   {
      public int compare(WidgetSuper1 o1, WidgetSuper1 o2)
      {
         return 1;
      }
   }
   public static class WidgetComparator implements Comparator<Widget>
   {
      public int compare(Widget o1, Widget o2)
      {
         return 0;
      }
   }
   public static class Widget1Comparator implements Comparator<Widget1>
   {
      public int compare(Widget1 o1, Widget1 o2)
      {
         return 1;
      }
   }
   public static class WidgetExtendComparator implements Comparator<WidgetExtend>
   {
      public int compare(WidgetExtend o1, WidgetExtend o2)
      {
         return 0;
      }
   }
   public static class WidgetExtend1Comparator implements Comparator<WidgetExtend1>
   {
      public int compare(WidgetExtend1 o1, WidgetExtend1 o2)
      {
         return 1;
      }
   }
   
   public static class LessThanWidget
   {}
   public static class WidgetSuper extends LessThanWidget
   {
      private Comparator<? super WidgetSuper> comparator = null;
      
      public WidgetSuper(Comparator<? super WidgetSuper> comparator)
      {
         this.comparator = comparator;
      }
      
      public int doSomething(WidgetSuper item)
      {
         return comparator.compare(this, item);
      }
   }
   public static class Widget extends LessThanWidget
   {
      private Comparator<Widget> comparator = null;
      
      public Widget(Comparator<Widget> comparator)
      {
         this.comparator = comparator;
      }
      
      public int doSomething(Widget item)
      {
         return comparator.compare(this, item);
      }
   }
   public static class WidgetExtend extends LessThanWidget
   {
      private Comparator<? extends WidgetExtend> comparator = null;
      
      public WidgetExtend(Comparator<? extends WidgetExtend> comparator)
      {
         this.comparator = comparator;
      }
      
      public int doSomething(WidgetExtend item)
      {
         // We can see why you never see Comparator<? extends 'anything' since they can't compile>
         return comparator.compare(this, item);
      }
   }
   public static class WidgetSuper1 extends WidgetSuper
   {
      public WidgetSuper1(Comparator<? super WidgetSuper> comparator)
      {
         super(comparator);
      }      
   }
   public static class Widget1 extends Widget
   {
      public Widget1(Comparator<Widget> comparator)
      {
         super(comparator);
      }
   }
   public static class WidgetExtend1 extends WidgetExtend
   {
      public WidgetExtend1(Comparator<? extends WidgetExtend> comparator)
      {
         super(comparator);
      }
   }
   
   public static final void main(String[] args)
   {
      new WidgetSuper(new LessThanWidgetComparator()); // <-- OK
      new WidgetSuper(new WidgetSuperComparator()); // <-- OK
      new WidgetSuper(new WidgetSuper1Comparator()); // <-- This is a compile error because WidgetSuper1 is not WidgetSuper or an ancestor 
      
      new Widget(new LessThanWidgetComparator()); // <-- This is a compile error because LessThanWidget is not an exact match of Widget 
      new Widget(new WidgetComparator()); // <-- OK
      new Widget(new Widget1Comparator()); // <-- This is a compile error because Widget1 is not an exact match of Widget
      
      new WidgetExtend(new LessThanWidgetComparator()); // <-- This is a compile error because LessThanWidget is not WidgetExtend nor does it extend from WidgetExtend 
      new WidgetExtend(new WidgetExtendComparator()); // <-- OK
      new WidgetExtend(new WidgetExtend1Comparator()); // <-- OK
   }
}

[Dr Cheaper]

You can also compare compare generics.

[Rob Spoor]

"Dr Cheaper",

Please read your private messages regarding an important announcement.

Thank you,

Rob