OOP Containment

Containment is an OOP concept where one class contains another class inside it. In simple terms, a big object is made from smaller objects.

A common phrase used to describe containment is:

This “has-a” relationship helps you build programs that are organised, easy to understand, and close to real-life situations.

Containment helps you in four ways:

• Break a large problem into smaller parts — instead of making one giant class, you create smaller, focused classes and combine them.
• Improve readability — each class handles one job, so your code becomes cleaner.
• Reuse classes — once you create a class like Engine or Student, you can use it in other programs.
• Model real-world objects — most real things are made up of smaller things. OOP tries to match this natural structure.

Students often confuse containment with inheritance. They are completely different concepts, and both are required in good program design:

Let us start with an easy example that matches real life. A car cannot work without an engine. The car is the main object; the engine is a part inside it.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

class Car:
    def __init__(self):
        self.engine = Engine(150)   # Car contains an Engine

my_car = Car()
print(my_car.engine.horsepower)     # 150

The Car object contains an Engine object. When you create a Car, the Engine is automatically created inside it. This is containment — and because the Engine is created inside the Car, it is also composition.

Containment can also mean “has many”. A library contains many book objects; a school contains many students. You store them in a list inside the container class.

class Book:
    def __init__(self, title):
        self.title = title

class Library:
    def __init__(self):
        self.books = []           # a list of Book objects

    def add_book(self, book):
        self.books.append(book)

# usage
b1 = Book("Hamlet")
b2 = Book("Macbeth")
lib = Library()
lib.add_book(b1)
lib.add_book(b2)
for b in lib.books:
    print(b.title)

There are two types of containment. The difference is whether the contained object can exist on its own.

# Composition
class Heart:
    def __init__(self):
        self.beats_per_minute = 72

class Human:
    def __init__(self):
        self.heart = Heart()   # Created inside the class

h = Human()
print(h.heart.beats_per_minute)   # 72

# Aggregation
class Student:
    def __init__(self, name):
        self.name = name

class School:
    def __init__(self):
        self.students = []        # Not created inside the class
    def add_student(self, student):
        self.students.append(student)

s1 = Student("Amina")   # created outside the School
s2 = Student("Hasib")   # created outside the School
my_school = School()
my_school.add_student(s1)
my_school.add_student(s2)
for s in my_school.students:
    print(s.name)

In Cambridge exam questions, containment is usually tested in four forms:

• Understanding relationships — identify whether a relation is “has-a” or “is-a”.
• Drawing class diagrams — you may be given a scenario and asked to draw classes with links.
• Writing classes — write classes that contain other classes.
• Explaining the difference — explain the difference between composition, aggregation, and inheritance.

Fifteen exam-style tasks. Click Hint for bullet-point guidance, then Help to reveal a worked Python solution.