Why Does Java Prevent Method Signature Duplication After Generic Erasure?

Method Signature Duplication and Generic Erasure

In Java, it is not permissible to declare two methods within the same class that have the same erasure after applying type erasure to their generic types. This restriction arises from the potential for conflicts with legacy code that utilizes raw types.

Consider the following example:

class Test {
   void add(Set<Integer> ii) {}
   void add(Set<String> ss) {}
}

This code would trigger the compilation error: "Method add(Set) has the same erasure add(Set) as another method in type Test."

To understand the rationale behind this restriction, let's trace the evolution of a hypothetical codebase:

Initially, before generics were introduced in Java, the following code might have been written:

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

Subsequently, an extension of this class was created:

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

With the introduction of generics, the CollectionConverter class was updated:

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

However, the Overrider class was left unchanged. To continue overriding the toList() method correctly, it was decided that raw types were "override-equivalent" to generified types.

Later, the developer of Overrider attempted to update the class but added a new method alongside the existing raw toList() method:

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

Due to the override equivalence of raw types, both methods could potentially override the toList(Collection) method. However, this ambiguity needed to be resolved for the compiler.

To prevent such conflicts, the Java language restricts the existence of multiple methods with the same erasure within a single class. This ensures that developers can confidently override methods without introducing ambiguity caused by legacy code that uses raw types.

The above is the detailed content of Why Does Java Prevent Method Signature Duplication After Generic Erasure?. For more information, please follow other related articles on the PHP Chinese website!