Inheritance vs Containership
Inheritance and Containership are two important concepts found in OOP (Object Oriented Programming Example: C++). In simple terms, both Containership and Inheritance deal with providing additional properties or behavior to a class. Inheritance is the ability for a class to inherit properties and behavior from a parent class by extending it. On the other hand, Containership is the ability of a class to contain objects of different classes as member data.
What is Inheritance?
As mentioned above, Inheritance is the ability for a class to inherit properties and behavior from a parent class by extending it. Inheritance essentially provides code reuse by allowing extending properties and behavior of an existing class by a newly defined class. If class A extends B, then class B is called the parent class (or super class) and class A is called the child class (or derived class/sub class). In this example scenario, class A will inherit all public and protected attributes and methods of the super class (B). The subclass can optionally override (provide new or extended functionality to methods) the behavior inherited from the parent class. Inheritance represents an “is-a” relationship in OOP. This essentially means that A is also a B. In other words, B can be the class with a general description of a certain real world entity but A specifies a certain specialization. In a real world programming problem, the Person class could be extended to create the Employee class. This is called specialization. But you could also first create the Employee class and then generalize it to a Person class as well (i.e. generalization). In this example, the Employee will have all the properties and behavior of the Person (i.e. Employee is also a Person) and may contain some additional functionality (so, Person is not an Employee) as well.
What is Containership?
Containership is the ability of a class to contain objects of different classes as member data. For example, class A could contain an object of class B as a member. Here, all the public methods (or functions) defined in B can be executed within the class A. Class A becomes the container, while class B becomes the contained class. Containership is also referred to as Composition. In this example, it can be said that class A is composed of class B. In OOP, Containership represents a “has-a” relationship. It is important to note that, even though the container has access to execute all the public methods of the contained class, it is not able to alter or provide additional functionality. When it comes to a real world programming problem, an object of class TextBox may be contained in the class Form, and thus can be said that a Form contains a TextBox (or alternatively, a Form is composed of a TextBox).
Difference between Inheritance and Containership
Although Inheritance and Containership are two OOP concepts, they are quite different in what they allow the programmer to achieve. Inheritance is the ability for a class to inherit properties and behavior from a parent class by extending it, while Containership is the ability of a class to contain objects of different classes as member data. If a class is extended, it inherits all the public and protected properties/behavior and those behaviors may be overridden by the subclass. But if a class is contained in another, the container does not get the ability to change or add behavior to the contained. Inheritance represents an “is-a” relationship in OOP, while Containership represents a “has-a” relationship.