5 Reasons To Purpose Composition Over Inheritance Inwards Coffee In Addition To Oop

Favor composition over inheritance is a 1 of the pop object-oriented blueprint principles, which helps to create flexible too maintainable code inwards Java too other object-oriented languages. Many times I receive got seen people suggesting work composition instead of inheritance, inwards fact, my favorite books similar Head kickoff Design Patterns equally good advocates this blueprint principle. Head kickoff books receive got its ain means of explaining, why composition is improve than inheritance too though its long its quite interesting too informative. It was the kickoff chapter of this book, which helped me a lot on agreement this telephone commutation OOPS concept. In this Java too OOPS tutorial, I receive got tried to summarize my sense unopen to composition too inheritance inwards ii nous category, first, departure betwixt composition too inheritance too second, when to work Composition over inheritance inwards Java. 

I receive got already mentioned nigh this blueprint principle, inwards my listing of 10 OOPS too SOLID blueprint principles for Java programmers, hither nosotros volition convey a to a greater extent than closer look.

Just to revise, composition too Inheritance are ways to reuse code to teach additional functionality. In Inheritance, a novel class, which wants to reuse code, inherit an existing class, known equally super class. This novel course of pedagogy is thus known equally sub class.

5 Reasons to Prefer Composition over Inheritance inwards Java

On composition, a class, which wish to work functionality of an existing class, doesn't inherit, instead it holds a reference of that course of pedagogy inwards a fellow member variable, that’s why the call composition. Inheritance too composition relationships are equally good referred equally IS-A too HAS-A relationships.

Because of IS-A relationship, an instance of sub course of pedagogy tin hold upwardly passed to a method, which accepts instance of super class. This is a form of Polymorphism, which is achieved using Inheritance.

Influenza A virus subtype H5N1 super course of pedagogy reference variable tin refer to an instance of sub class. By using composition, you lot don’t teach this behavior, but nevertheless it offers a lot to a greater extent than to tilde the residual inwards its side.


1) One argue of favoring Composition over Inheritance inwards Java is fact that Java doesn't back upwardly multiple inheritance. Since you lot tin alone extend 1 course of pedagogy inwards Java, but if you lot demand multiple functionality similar e.g. for reading too writing grapheme information into file, you lot demand Reader too Writer functionality too having them equally mortal members makes your project easy. That’s called composition. If you lot are next programming for interface than implementation principle, too using type of base of operations course of pedagogy equally fellow member variable, you lot tin work dissimilar Reader too Writer implementation at dissimilar situation. You won’t teach this flexibility yesteryear using Inheritance, inwards instance of extending a class, you lot alone teach facilities which are available at compile time.


2) Composition offers improve test-ability of a course of pedagogy than Inheritance. If 1 course of pedagogy is composed of some other class, you lot tin easily create Mock Object representing composed course of pedagogy for sake of testing. Inheritance doesn't render this luxury. In gild to essay derived class, you lot must demand its super class. Since unit of measurement testing is 1 of the most of import affair to consider during software development, specially inwards essay driven development, composition wins over inheritance.


3) Many object oriented blueprint patterns mentioned yesteryear Gang of Four inwards at that topographic point timeless classic Design Patterns: Elements of Reusable Object-Oriented Software, favors Composition over Inheritance. Classical examples of this is Strategy blueprint pattern, where composition too delegation is used to alter Context’s behavior, without touching context code. Since Context uses composition to concur strategy, instead of getting it via inheritance, it’s slow to render a novel Strategy implementation at run-time. Another skillful illustration of using composition over inheritance is Decorator blueprint pattern. In Decorator pattern, nosotros don't extend whatever course of pedagogy to add together additional functionality, instead nosotros proceed an instance of the course of pedagogy nosotros are decorating too delegates original project to that course of pedagogy afterwards doing decoration. This is 1 of the biggest proof of choosing composition over inheritance, since these blueprint patterns are good tried too tested inwards dissimilar scenarios too withstand essay of time, keeping at that topographic point caput high.

4) Though both Composition too Inheritance allows you lot to reuse code, 1 of the disadvantage of Inheritance is that it breaks encapsulation. If sub course of pedagogy is depending on super course of pedagogy demeanour for its operation, it of a precipitous becomes fragile. When demeanour of super course of pedagogy changes, functionality inwards sub course of pedagogy may teach broken, without whatever alter on its part. One illustration of inheritance making code delicate is method add() too addAll() from HashSet. Suppose, If addAll() of HashSet is implemented yesteryear calling add() method too you lot write a sub course of pedagogy of HashSet, which encrypt the content earlier inserting into HashSet. Since at that topographic point are alone 1 methods add(), which tin insert object into HashSet you lot override these method too called your encrypt() method yesteryear overriding add(). This automatically covers addAll() equally well, because addAll() is implemented using add(), it looks really enticing.If you lot await closely you lot volition meet that this implementation is fragile, because its relied on super course of pedagogy behavior. If base of operations course of pedagogy wants to improve performance too implements addAll() without calling add() method, next illustration volition break.

public class EncryptedHashSet extends HashSet{     .....      public boolean add(Object o) {        return super.add(encrypt(o));     }  }

If you lot receive got used Composition inwards favor of Inheritance you lot won't confront this job too your course of pedagogy would receive got been to a greater extent than robust, because you lot are non relying on super course of pedagogy demeanour whatever more. Instead you lot are using super course of pedagogy method for add-on component too you lot volition practice goodness amongst whatever improvement inwards addAll() equally shown inwards below example:

public class EncryptedHashSet implements Set{      private HashSet container;      public boolean add(Object o) {        return container.add(encrypt(o));     }      public boolean addAll(Collection c) {        return conatainer.add(encrypt(c));     }      ....... }

In short, don't work Inheritance simply for the sake of code reuse, Composition allows to a greater extent than flexible too extensible machinery to reuse code. Make sure you lot don't forget this rule, if you lot don't to practice this :)

5. Another argue of favoring Composition over inheritance is flexibility. If you lot work Composition you lot are flexible plenty to supervene upon implementation of Composed course of pedagogy amongst improve too improved version. One illustration is using Comparator class which provides compare functionality. if your Container object contains a Comparator instead of extending a item Comparator for comparing , its easier to alter the means comparing is performed yesteryear setting dissimilar type of Comparator to composed instance, piece inwards instance of inheritance you lot tin alone receive got 1 comparing demeanour on runtime, You tin non alter it runtime.


There are many to a greater extent than reasons to favor Composition over inheritance, which you lot volition start discovering in 1 trial you lot start using blueprint patterns inwards Java. In nutshell favoring Composition results inwards to a greater extent than flexible too robust code than using Inheritance. Though at that topographic point are sure enough some cases where using Inheritance makes much sense similar when a genuine bring upwardly nipper relation exists, but most of fourth dimension it makes sense to favor composition over inheritance for code reuse. There is an item of this theme on my some other favorite book, Effective Java, which has equally good helped me to empathize this concept better, you lot may wish to await that equally well.


Further Learning
Design Pattern Library
From 0 to 1: Design Patterns - 24 That Matter - In Java
Java Design Patterns - The Complete Masterclass

Bagikan Artikel ini