Inheritance might be the most unjustly maligned language feature.
The amount of effort that has been expended at the language level to tame it over the decades has been extraordinary.
Java dropped multiple inheritance and offered interfaces to cut away some hazard. Scala introduced traits; Ruby introduced modules.
But you can use inheritance safely if you just follow a few guidelines.
1. Only inherit to complete an abstraction. Abtract classes have empty spaces that you fill. Don’t override anything concrete.
2. Preserve client context. No existing client should be surprised by the behavior you add via a subclass. When you follow guideline 1 this is easy.
3. Don’t mix concerns in a hierarchy. The hierarchy is the unit of responsibility. Not the class.
That’s it. You end up with shallow manageable hierarchies.
You could always “prefer composition to inheritance” but that’s too far. Some inheritance based solutions are elegant and if you follow the three guidelines you can easily refactor if you need to.
