[note: This question was originally tagged as being language-agnostic. Based on that, this answer was written to be fairly language agnostic, so it discusses inheritance as it’s used across a wide range of languages, such as Smalltalk, C++, and Object Pascal. It’s since been re-tagged as being specifically about Java. Java is different in defining a
class and an
interface as two entirely separate things. The idea that the purpose of inheritance is code reuse, not polymorphism is reasonable from a Java-specific viewpoint, but clearly wrong from a language-agnostic viewpoint. If you only care about Java, this probably isn’t the best answer.]
The purpose of inheritance is code reuse, not polymorphism.
This is your fundamental mistake. Almost exactly the opposite is true. The primary purpose of (public) inheritance is modeling the relationships between the classes in question. Polymorphism is a large part of that.
When used correctly, inheritance isn’t about reusing existing code. Rather, it’s about being used by existing code. That is to say, if you have existing code that can work with the existing base class, when you derive a new class from that existing base class that other code can now automatically work with your new derived class as well.
It is possible to use inheritance for code re-use, but when/if you do so it should normally be private inheritance not public inheritance. If the language you’re using supports delegation well, chances are pretty good that you rarely have much reason to use private inheritance. OTOH, private inheritance does support a few things that delegation (normally) doesn’t. In particular, even though polymorphism is a decidedly secondary concern in this case, it can still be a concern — i.e., with private inheritance you can start from a base class that’s almost what you want, and (assuming it allows it) override the parts that aren’t quite right.
With delegation your only real choice is to use the existing class exactly as it stands. If it doesn’t do quite what you want, your only real choice is to ignore that functionality completely, and re-implement it from the ground up. In some cases that’s no loss, but in others it’s quite substantial. If other parts of the base class use the polymorphic function, private inheritance lets you override only the polymorphic function, and the other parts will use your overridden function. With delegation, you can’t easily plug in your new functionality so other parts of the existing base class will use what you’ve overridden.