Why neatly-liked inheritance is erroneous and the procedure to lastly fix it

Why neatly-liked inheritance is erroneous and the procedure to lastly fix it

By leveraging composition and the closing key phrase within the loyal methodology, you might purple meat up your programming abilities and switch out to be a greater Java programmer.  

In fashion inheritance, whereby a public class is prolonged over kit boundaries, gives a sequence of challenges and downsides and ought to be averted in on the area of all conditions. Courses and strategies would be made closing which implies that subclassing is disallowed which effectively prevents inheritance. Whereas this will likely also sound admire a queer thing to make in an object-oriented language admire Java, it does elevate fundamental advantages for a limiteless sequence of class types.

But, when ought to composed a class or methodology be closing and loyal why is neatly-liked inheritance problematic?

Immutable Courses

Immutable classes are classes whose divulge can no longer be seen to alternate from the outside world. This gives immutable objects the unswerving thing about being inherently thread-estimable and as well they might well be reused indefinitely.

Java’s constructed-in String class is an example of an immutable class. It does hang an internal divulge that is terribly more likely to alternate the critical time hashCode() is named, however this internal divulge can’t be seen by an out of doors caller (unless resorting to reflection).

Immutable classes shall repeatedly be declared closing or else subclasses might well compromise the immutability contract, simply by adding and exposing a mutable divulge. 

For the sake of completeness, it is worth pointing out that an immutable class ought to composed repeat all its fields as personal, closing and make obvious that queer ranking admission to to any mutable sub-factor (reminiscent of an array), as an illustration the usage of defensive copying.

Non-instantiable Courses (aka Utility Courses)

A non-instantiable class is always informally continuously known as a “utility class” and comprises very top static systems (and presumably static fields). Static systems are no longer class systems however pretty global features attached to a “provider-class”.  Ideally, non-instantiable classes ought to be immutable pertaining to their (static) divulge (if any).

These systems ought to be known as the usage of their provider-class title followed by the methodology title (e.g. Collections.emptyList()). Subclassing a non-instantiable utility might well no longer sleep in non-intuitive habits and is probably going a supply of bewilderment as the systems can’t be overridden at the least, very top replaced as illustrated hereunder:

public class FooUtil {

    static void print() {



    static void lower() {

        Plot.out.println(“lower foo”);



public class BarUtil extends FooUtil {

    static void lower() {

        Plot.out.println(“lower bar”);



Invoking BarUtil::print will impact “lower foo” and no longer “lower bar” which implies that BarUtil::lower did no longer override FooUtil::lower. On the opposite hand, if BarUtil::lower was as soon as known as straight away, it would hang printed “lower bar”.

Therefore, non-instantiable classes ought to composed in total be declared closing

As an aspect characterize, non-instantiable classes ought to composed hang a single default constructor declared personal to prevent instantiation of the non-instantiable class (as the title implies).

Methods Known as by a Constructor

Methods known as by a constructor of a class ought to composed repeatedly be closing, either by declaring your entire class closing or by declaring these systems closing. Failure to make that can start up a leak of an object (e.g. “this”) that is extremely top partially initialized and thus is probably going in an unlawful divulge. This kind of leak might well, as an illustration, happen by the no longer-yet-initialized occasion registering itself with a listener. These errors are likely exhausting to title within the event that they assign it out within the start.

In fashion Inheritance

The utilize/non-utilize of neatly-liked inheritance has sparked opinionated discussions for rather some time.

Abet within the early days, inheritance was as soon as commonly regarded as the neatly-liked methodology of code reuse. As it later turned out, inheritance outside a kit might well lead to unsatisfiable and counterfeit behaviour unless particular care is place into offering classes which can be enough to extend all the procedure thru kit boundaries [Bloch18, Item18]. 

Furthermore, neatly-liked inheritance breaks encapsulation [Snyder80] for the rationale that superclass implementation might alternate over time which might cause a subclass to fail even supposing no changes hang been made. This pains would be averted if one commits to never alternate the superclass, effectively making the superclass a limiteless monolithic fossil API commitment for eternal cases. In all fairness, this argument can moreover be raised against classes the usage of composition even supposing there are fewer systems concerns can leak into the code. So, right here is no longer an argument for finalization however pretty a extra essential pains with code reuse.

Inheritance might well impact unintended outcomes as a consequence of self-utilize, whereby an overridable methodology calls one other overridable methodology within the outrageous class: Factor in a class that extends ArrayList and that’s presupposed to personal note of the sequence of ingredients ever added to the category. If we override add() bumping the counter by one and override addAll(Collection) adding Collection.dimension() to the counter after which the corresponding huge methodology is named,  then we’re in for a surprise: 

Which capacity that of ArrayList::addAll occurs to self-utilize ArrayList::add to personally add the ingredients, additions thru addAll() will count twice. Furthermore, there isn’t any longer this kind of thing as a guarantee that this habits will cease the identical over time unless it is documented. Doubtless there can be a extra performant methodology of bulk-adding ingredients within the waste whereby ingredients are straight away inserted within the backing array without calling add()?

But every other total pains with self-utilize is when a subclass overrides a technique that is presupposed to name one or loads of alternative systems however the programmer forgets to name the massive methodology. A related pains is the pains of deciding if an overriding methodology ought to composed name the massive methodology firstly or at the tip of the overridden methodology (or certainly someplace in between).  A plot to a couple of those concerns would be to repeat the tip methodology closing within the outrageous class and provide overridable estimable “hook systems” that would be overridden in a extra managed fashion. 

In fashion inheritance moreover opens up likely safety vulnerabilities: Bid an ArrayList was as soon as prolonged to be fade that very top objects gratifying a obvious predicate would be added (e.g. they ought to be in a sound divulge). Then, in a later inaugurate, a brand serene methodology of adding ingredients was as soon as equipped thru the outrageous class AbstractList. This serene methodology will now develop into visible within the supposedly safeguarded class, effectively offering a assist-door for adding unlawful objects to the list. 

But every other pains is “propagating publicity” as exemplified by  Arrays.asList(“a”, “b”) which returns a “mounted-dimension list” (however ought to advance an unmodifiable Record and right here an immutable Record as the ingredients themselves are all immutable). As it appears, ingredients within the returned Record might well now no longer very top get replaced thru an Iterator however moreover thru the Record::replaceAll,a  methodology added in JDK 8 after the inception of Arrays::asList.

An further class of concerns might come up if a subclass provides a brand serene methodology to the ones of the outrageous class. If at a later stage, a technique with the identical signature is added to the outrageous class, then this methodology can be coincidentally overridden by the subclass. Here is probably going no longer the intended habits at all. If a technique with the identical title and parameters are added however with a undeniable return form, then the code will likely fail to assemble. So within the neatly-liked case, it is no longer conceivable to ever add systems in a non-closing public class as there isn’t any longer this kind of thing as a administration of how the category is subclassed.

But one other pains would be incidental inheritance. The JDK itself has loads of problematic inheritances whereby classes hang been incidentally inherited attributable to it was as soon because it appears to be “useful“ and no longer attributable to class B certainly was as soon as class A. For instance, Stack extends the primitive Vector class for no loyal essential motive. This prevents Stack from evolving to a extra efficient and performant implementation.

To summarize, a class that is presupposed to be in total inherited is terribly exhausting to ever alternate and must [Bloch18, Item19]:

  • Doc its self-utilize of overridable systems

  • Doubtlessly offering hooks within the form of judiciously chosen conserving systems

  • Be accompanied by checks the usage of subclasses

  • No longer provide a constructor that invokes overridable systems

  • No longer enable serialization to invoke overridable systems

Inheriting moreover creates constraints and concerns if hashCode()/equals() are overridden. If we hang a outrageous class known as Fruit, then is an Apple with the identical color as a Pear equal? Can an occasion of SevilleOrange ever be equal to a BergamontOrange occasion?  In total, it is difficult to take all these questions. It is a necessity to be conscious that any subclass ought to composed either override none of those systems or ought to composed override them both.

It ought to be neatly-known that exposing a public non-closing class in a public API by definition capacity that it opens up for inheritance all the procedure thru kit boundaries as user-land code can space extending classes in any packet. Since split packages are strongly uncomfortable or might even be totally forbidden reckoning on the usage of JPMS, subclassing this kind of class implies subclassing over kit boundaries.

One methodology of warding off all these items is to repeat classes closing and utilize composition rather than inheritance, effectively leaving gradual inheritance all the procedure thru packages. This commonly gives an improbable cleaner API whereby very top interfaces would be uncovered and concrete classes make no longer leak out within the API. This methodology, any superclass feeble is extremely top kit-personal and might well, by convention or definition, never be feeble externally.

Composition with delegation protects against many of the concerns mentioned above including unintended self-utilize, safety holes thru further systems in outrageous classes, signature collisions,  incidental inheritance, need of subclass testing, unintended leak of “this” and heaps other concerns. Within the previous, it was as soon as feared that this might well perhaps lead to reduced efficiency however right here is simply no longer the case.

Inheritance in Java is, for loyal reasons, restricted to one superclass which naturally limits the scalability of the notion. Composition, on the opposite hand, permits an arbitrary sequence of delegates to be feeble.

A cramped scrape with composition might well materialize in mixture with the usage of obvious callbacks. On the opposite hand, this pains would be averted if loyal provisions are place in. In other phrases, if a part (feeble in composition) registers itself with a listener, then the listener will invoke the factor itself and no longer the composing class.

Sealed Courses

In further newest Java versions, the notion of sealed classes (JEP 409) was as soon as equipped. Old to this, the closing key phrase was as soon as a boolean property: either a class was as soon as extensible (within its declared ranking admission to form) or it was as soon as no longer. Sealed classes introduce a extra granular mechanism whereby it’ll be said that a Fruit can either be an Apple, Pear or Orange however nothing extra. Here is basically a extra generalized fashion of closing. The amount of effort place into the Java languages with ingredients admire this indicates a class extensibility is a mandatory property. Interestingly, a accredited class in a sealed interface must specify whether itself is closing, non-closing or permits subsequent subclasses. 

API Commitments Imposed by Inheritance

In this text, the category Stack was as soon as mentioned as a failed inheritance implementation. It generally introduces the systems push(), pop(), take a look at(), empty() and search(). But, because it inherits from Vector, we moreover ranking the entire systems/classes from Record, AbstractList, RandomAccess, Cloneable and SerializableAbstractList, which in flip, inherits from AbstractCollection which implements Collection.

This will increase the API weight by orders of magnitudes and I’m completely obvious the Java designers are regretting their incidental inheritance 25 years down the road. If Stack was as soon as loyal an interface and there was as soon as a static methodology readily within the market that equipped a brand serene empty Stack, issues would glimpse great better.

Courses which can be Serializable or area to other serialization mechanisms are every so continuously particularly problematic as the binary (or other) format as a rule limits the methodology implementations can ever evolve over time.

As viewed above and in outdated clauses, a public non-closing class can’t ever alternate in many conditions.

Must Inheritance Across Kit Boundaries Ever be Stale?

Here’s a topic of notion. 

Time and again, it is better to make utilize of composition. In further efficient conditions delivering features to a concrete class’ constructor offering tailored functionality would be preferable over allowing subclassing and overriding systems. To give an example of this, rather than overriding a handler methodology, a technique handler would be equipped thru the constructor to a non-extensible class.

If, after very cautious consideration, one arrives at the conclusion that one ought to composed provide an extensible class (all the procedure thru packages), then the entire constraints above ought to be taken into cautious consideration. Lawful allowing subclassing by default is a loyal-out mistake, particularly for library and API designers. As a replace, classes ought to be marked closing by default, and extremely top after cautious review and testing, opening up for subclassing would be regarded.

A Closing Impart

As I moved a ways flung from the usage of inheritance all the procedure thru packages and switched to exposing loyal interfaces, many other advantages turned apparent. It turns into great more uncomplicated to personal internal concerns… effectively internal.

Composition whereby doubtlessly loads of ingredients would be feeble in a single class gives extra code reuse functionality than inheritance, albeit requiring fair a diminutive extra code ceremony within the the usage of class. It might well perhaps perchance most likely perhaps moreover simplify testing of the code and gives better take a look at protection with great fewer and much less brittle checks.

It moreover fits thoroughly with the module machine (JPMS).  Offering ingredients as pure products and companies, as an illustration, the usage of Java’s ServiceLoader, provides flexibility whereas minimizing the API footprint. This makes it more uncomplicated to learn and utilize the API and gives great extra flexibility to conform libraries over time. 

At final, it all makes sense…



Bloch, Joshua., Efficient Java, Third Edition, ISBN 0-13-468599-7, 2018


Snyder, Allan. “Encapsulation and Inheritance in Object-Oriented Programming Languages”. In Object-Oriented Programming Programs, Language and Capabilities Proceedings, 35-45, New-York, NY ACM Press.



Hey! look, i give tutorials to all my users and i help them!