Method has the same erasure as another method in type

by

This rule is intended to avoid conflicts in legacy code that still uses raw types.

Here’s an illustration of why this was not allowed, drawn from the JLS. Suppose, before generics were introduced to Java, I wrote some code like this:

class CollectionConverter {
  List toList(Collection c) {...}
}

You extend my class, like this:

class Overrider extends CollectionConverter{
  List toList(Collection c) {...}
}

After the introduction of generics, I decided to update my library.

class CollectionConverter {
  <T> List<T> toList(Collection<T> c) {...}
}

You aren’t ready to make any updates, so you leave your Overrider class alone. In order to correctly override the toList() method, the language designers decided that a raw type was “override-equivalent” to any generified type. This means that although your method signature is no longer formally equal to my superclass’ signature, your method still overrides.

Now, time passes and you decide you are ready to update your class. But you screw up a little, and instead of editing the existing, raw toList() method, you add a new method like this:

class Overrider extends CollectionConverter {
  @Override
  List toList(Collection c) {...}
  @Override
  <T> List<T> toList(Collection<T> c) {...}
}

Because of the override equivalence of raw types, both methods are in a valid form to override the toList(Collection<T>) method. But of course, the compiler needs to resolve a single method. To eliminate this ambiguity, classes are not allowed to have multiple methods that are override-equivalent—that is, multiple methods with the same parameter types after erasure.

The key is that this is a language rule designed to maintain compatibility with old code using raw types. It is not a limitation required by the erasure of type parameters; because method resolution occurs at compile-time, adding generic types to the method identifier would have been sufficient.

More Related Contents:

  1. Java generics type erasure: when and what happens?
  2. What are the reasons why Map.get(Object key) is not (fully) generic
  3. Java: how do I get a class literal from a generic type?
  4. What is SuppressWarnings (“unchecked”) in Java?
  5. Why is “extends T” allowed but not “implements T”?
  6. Bounding generics with ‘super’ keyword
  7. Java Generics – Bridge method?
  8. Lambda Expression and generic defined only in method
  9. How to implement enum with generics?
  10. Reflection type inference on Java 8 Lambdas
  11. Why can’t you have multiple interfaces in a bounded wildcard generic?
  12. Use of ‘? extends ‘ and ‘? super ‘ in Collection generics [duplicate]
  13. Java Type Generic as Argument for GSON
  14. Java Generic Class – Determine Type
  15. How to have Java method return generic list of any type?
  16. How does Gson TypeToken work?
  17. What’s the difference between raw types, unbounded wild cards and using Object in generics
  18. Java generics issue: Class “not within bounds of type-variable” error.
  19. Nested wildcards
  20. Type erasure, overriding and generics
  21. How to create ArrayList (ArrayList) from array (int[]) in Java
  22. How would contravariance be used in Java generics?
  23. mocking a method that return generics with wildcard using mockito
  24. Using a generic class to perform basic arithmetic operations
  25. Generic method in Java without generic argument
  26. Using a generic type with Gson
  27. Java generics – ArrayList initialization
  28. How to write a generic method that takes two arguments of the same types in java?
  29. Java generics: wildcard vs type parameter?
  30. Provide an iterator over the contents of two lists simultaneously?

Leave a Comment