The right way to implement generic interface

Question

The example will be shown on Comparable, but the question is about all similar situations.

So Comparable is a generic Interface:

public interface Comparable<T>

We can implement it in two ways (mainly):

Implement with a generic type and override compareTo method with known-type parameter:

MyClass implements Comparable<MyClass> {
   @Override
   public int compareTo(MyClass o) {
      return myVar.compareTo(o.myVar)
   }
}

Implement with no generic type and use compareTo with Object parameter:

MyClass implements Comparable {
   @Override
   public int compareTo(Object o) {
      return myVar.compareTo(((MyClass)o).myVar)
   }
}

Which approach is more acceptable? What are the pros and cons of each other? I guess that the first approach is better, as there is no additional casting, but is this the only advantage?

Using the second form will generate a compiler warning. Ignoring generics results in code that makes unsafe assumptions. Such code is likely to result in mysterious bugs and exceptions. It is a very good idea to turn all compiler warnings when building. — VGR, Mar 11 '19 at 01:21

score 1 · Accepted Answer · answered Mar 10 '19 at 22:51

It wouldn't make any sense if you used the second one without doing a typecheck before the first one. Leave it to the compiler to make those checks and just choose for the first option.

In this particular case, choosing the first option makes sure your Comparator contract is fulfilled by comparing 100% of the time two objects from the same type.

In general, if generics are defined in a superior class, it is mostly for a good reason allowing a better usability by providing more readable and maintainable code plus compile time type checking.

Also, the second variation is slower because it makes a run time type check on each call, where the first resolves all that at compile time. — Gene, Mar 10 '19 at 23:05

The right way to implement generic interface

1 Answers1