Item 41 - Use overloading judiciously

From Effective Java 2/e by Joshua Bloch

  • The choice of which overloading to invoke is made at compile time
  • Selection among overloaded methods is static, while selection among overridden methods is dynamic.
  • The compile-time type of an object has no effect on which method is executed when an overridden method is invoked; the “most specific” overriding method always gets executed. Compare this to overloading, where the runtime type of an object has no effect on which overloading is executed;

Example shows difference between overloading and overriding

// It prints Unknown Collection three times
public class CollectionClassifier {
   public static String classify(Set<?> s) {
      return "Set";
   public static String classify(List<?> lst) {
      return "List";
   public static String classify(Collection<?> c) {
      return "Unknown Collection";
   public static void main(String[] args) {
      Collection<?>[] collections = {
         new HashSet<String>(),
         new ArrayList<BigInteger>(),
         new HashMap<String, String>().values()
      for (Collection<?> c : collections)
// It prints out wine, sparkling wine, and champagne
class Wine {
   String name() { return "wine"; }
class SparklingWine extends Wine {
   @Override String name() { return "sparkling wine"; }
class Champagne extends SparklingWine {
   @Override String name() { return "champagne"; }
public class Overriding {
   public static void main(String[] args) {
      Wine[] wines = {
         new Wine(), new SparklingWine(), new Champagne()
      for (Wine wine : wines)

Avoid confusing uses of overloading

  • A safe, conservative policy is never to export two overloadings with the same number of parameters
// ObjectOutputStream
void writeBoolean(boolean);
void writeInt(int);
void writeLong(long);

boolean readBoolean();
int readInt();
long readLong();
  • For constructors, you do have the option of exporting static factories instead of constructor
  • When at least one corresponding formal parameter in each pair of overloadings has a “radically different” type in the two overloadings

Confusion by auto-boxing

// It prints out [-2, 0, 2]
public class ListOverloading {
   public static void main(String[] args) {
      List<Integer> list = new ArrayList<Integer>();
      for (int i = -3; i < 3; i++)
      for (int i = 0; i < 3; i++)
         list.remove(i); // should be list.remove((Integer) i);

public class List {
   void remove(int);
   void remove(E);

There may be times when you feel the need to violate the guidelines in this item, especially when evolving existing classes.

  • The standard way to ensure this behavior is to have the more specific overloading forward to the more general
public boolean contentEquals(StringBuffer sb) {
   return contentEquals((CharSequence) sb);

Posted by The Finest Artist