Composition and Inheritance in Object Oriented Programming

Shakti Saxena

14 Comments

Join the conversation! Your thoughts help the community grow.

Bhuvanesh Mohankumar10y ago
Good one..
Sonu Chaudhary10y ago
good
Ratnesh Singh11y ago
nice
Yashwanth Muthineni11y ago
Nice Share
Santhakumar Munuswamy11y ago
Good Article. Thanks for sharing
Nilesh Jadav11y ago
Thanks for sharing
Gowtham K11y ago
Good one
Rajeesh Menoth11y ago
Good Share..
Vaikesh K P11y ago
Good
Rakesh11y ago
Good share sir
Gopi Chand11y ago
Nice work
Karthikeyan K11y ago
Good one sir...
Mohammed Ibrahim11y ago
nice
Pankaj Kumar Choudhary11y ago
Nice Explain Sir...........

Composition and Inheritance are two words in Object-Oriented languages used on a daily basis. When you are trying to explain some problem using design patterns, it’s very unlikely to escape these two magic words. Well, the question I always ask or want to ask is, do you know what they mean and when and where to use them in actual contexts? I often see developers asking the same question again and again. Let me try my best to explain it.

Inheritance describes a superclass-childclass relationship where a derived class or child class has all the features of the super class or parent class.

Inheritance

It defines a relationship of type “is-a”.

Examples

A car is a vehicle
TextEditor is an editor
HtmlEditor is an editor

Inheritance

Let’s say a class B (child class) inherits from class A (base class or super class). Therefore, class B has access to all methods and fields of type public or protected from Class A.

Class A

public class A{
public bool MethodA()
{
return true;
}
}

Class B

class B: A
{
public bool MethodB()
{
return base.MethodA();
}
}

Composition describes an ownership. One class contains an object of another class, in other words a car class has an object of class engine in it.

Composition

It defines a relationship of type “has-a”.

Example

A car has an engine.
A house has a kitchen.
A motherboard has a processor
A text editor has a button and text area

Class A

class A{
public bool MethodA()
{
return true;
}
}
//composition way
class B
{
A a= new A();
public bool MethodB()
{
return a.MethodA();
}
}

Let’s combine them together and see how they go together:

Now let’s say in our client we invoke a method from class B that in turn invokes MethodA() from class A.

main(string [] args)
{
B b= new B();
Console.writeline(b.MethodB()); // in this case the writeline function would always print Boolean value as true.
}

If you observe the code above, class B with of the both behaviors composition and inheritance, produce the same results.

Let’s make the difference:

Now let’s say instead of returning true from MethodA() from base class (Class A), we modify its behavior. Now it returns a string instead of a bool.

Changed Code from Class A

Class A
{
public string MethodA()
{
return “Mario”;
}
}

If we compile the existing code as it is, Class B (Inheritence) is extending from class A and therefore would not compile. Because the class A MethodA() no longer returns a boolean value.

Now understand it from the Composition point of view as in the following:

Class B
{
A a= new A(); // composition
Public bool MethodB()
{
return a.MethodA()==”Mario”?true:false;
}

Class B with composition also fails to compile but the advantages with composition is that with a little tweaking of the code, we still get the expected results and the client does not crash unlike with inheritance.

My argument is not about choosing composition over inheritance. The decision should be based on the proper relationship hierarchy among classes. My point is, to favor Composition over Inheritance is code reuse without extending a class. Which means one class can reuse multiple classes but with Inheritance you are only limited to reusing code from one class.