Java8: Why is it forbidden to define a default method for a method from java.lang.Object

by

This is yet another of those language design issues that seems “obviously a good idea” until you start digging and you realize that its actually a bad idea.

This mail has a lot on the subject (and on other subjects too.) There were several design forces that converged to bring us to the current design:

  • The desire to keep the inheritance model simple;
  • The fact that once you look past the obvious examples (e.g., turning AbstractList into an interface), you realize that inheriting equals/hashCode/toString is strongly tied to single inheritance and state, and interfaces are multiply inherited and stateless;
  • That it potentially opened the door to some surprising behaviors.

You’ve already touched on the “keep it simple” goal; the inheritance and conflict-resolution rules are designed to be very simple (classes win over interfaces, derived interfaces win over superinterfaces, and any other conflicts are resolved by the implementing class.) Of course these rules could be tweaked to make an exception, but I think you’ll find when you start pulling on that string, that the incremental complexity is not as small as you might think.

Of course, there’s some degree of benefit that would justify more complexity, but in this case it’s not there. The methods we’re talking about here are equals, hashCode, and toString. These methods are all intrinsically about object state, and it is the class that owns the state, not the interface, who is in the best position to determine what equality means for that class (especially as the contract for equality is quite strong; see Effective Java for some surprising consequences); interface writers are just too far removed.

It’s easy to pull out the AbstractList example; it would be lovely if we could get rid of AbstractList and put the behavior into the List interface. But once you move beyond this obvious example, there are not many other good examples to be found. At root, AbstractList is designed for single inheritance. But interfaces must be designed for multiple inheritance.

Further, imagine you are writing this class:

class Foo implements com.libraryA.Bar, com.libraryB.Moo { 
    // Implementation of Foo, that does NOT override equals
}

The Foo writer looks at the supertypes, sees no implementation of equals, and concludes that to get reference equality, all he need do is inherit equals from Object. Then, next week, the library maintainer for Bar “helpfully” adds a default equals implementation. Ooops! Now the semantics of Foo have been broken by an interface in another maintenance domain “helpfully” adding a default for a common method.

Defaults are supposed to be defaults. Adding a default to an interface where there was none (anywhere in the hierarchy) should not affect the semantics of concrete implementing classes. But if defaults could “override” Object methods, that wouldn’t be true.

So, while it seems like a harmless feature, it is in fact quite harmful: it adds a lot of complexity for little incremental expressivity, and it makes it far too easy for well-intentioned, harmless-looking changes to separately compiled interfaces to undermine the intended semantics of implementing classes.

More Related Contents:

  1. When to use: Java 8+ interface default method, vs. abstract method
  2. Explicitly calling a default method in Java
  3. Purpose of Default or Defender methods in Java 8
  4. When is an interface with a default method initialized?
  5. What are the differences between abstract classes and interfaces in Java 8?
  6. Why is “final” not allowed in Java 8 interface methods?
  7. What is the “default” implementation of method defined in an Interface?
  8. Java 8 default methods as traits : safe?
  9. Why are class static methods inherited but not interface static methods?
  10. Super class method and Interface default method conflict resolution
  11. Implementing two interfaces with two default methods of the same signature in Java 8
  12. Do Java 8 default methods break source compatibility?
  13. What is the purpose of the default keyword in Java?
  14. Can an interface method have a body?
  15. Are defaults in JDK 8 a form of multiple inheritance in Java?
  16. What is the reason why “synchronized” is not allowed in Java 8 interface methods?
  17. convert String list in List of object [duplicate]
  18. What’s the difference between map() and flatMap() methods in Java 8?
  19. Java 8 lambdas, Function.identity() or t->t
  20. The difference between the Runnable and Callable interfaces in Java
  21. Reflection type inference on Java 8 Lambdas
  22. Java 8: How do I work with exception throwing methods in streams?
  23. Java 8 LocalDateTime deserialized using Gson
  24. Java Streams: How to do an efficient “distinct and sort”?
  25. How to get a Stream from a float[]
  26. Difference between findAny() and findFirst() in Java 8
  27. Add Buttons to Tabs and Tab area JavaFX
  28. Does collect operation on Stream close the stream and underlying resources?
  29. How to get multiple values from an object using a single stream operation?
  30. How to serialize a class with an interface?

Leave a Comment