Has-a versus Is-a: Why Prefer Composition

18 min · Intermediate

Every class design starts with one question: is this object a kind of that one, or does it have that one? Inheritance answers the first. Composition answers the second, and it is usually the safer choice.

Is-a means inheritance

Is-a relationship means one class is a more specific kind of another, such as a Manager being an Employee. Python models it with inheritance: class Manager(Employee).

A Manager is an Employee. Anything you can do with an Employee, you can do with a Manager. That is the test for inheritance.

Python

1class Employee:2    def __init__(self, name):3        self.name = name4
5    def role(self):6        return "Employee"7
8
9class Manager(Employee):10    def role(self):11        return "Manager"

Example 1 · A Manager is an Employee

Python

1class Employee:2    def __init__(self, name):3        self.name = name4
5    def role(self):6        return "Employee"7
8
9class Manager(Employee):10    def role(self):11        return "Manager"12
13
14m = Manager("Asha")15print(m.name, m.role())16print(isinstance(m, Employee))

Output

Asha Manager
True

What this code does

Manager reuses name and overrides role.
isinstance is True because a Manager really is an Employee.

Use inheritance only when the child can stand in for the parent everywhere.

Has-a means composition

Composition means building an object from other objects it holds as attributes (a has-a relationship). The whole delegates work to its parts instead of inheriting from them.

A Customer is not an Address. A Customer has an Address. So the Customer keeps an Address object in an attribute and asks it for help.

Example 2 · A Customer has an Address

Python

1class Address:2    def __init__(self, city, pin):3        self.city = city4        self.pin = pin5
6    def label(self):7        return f"{self.city} - {self.pin}"8
9
10class Customer:11    def __init__(self, name, address):12        self.name = name13        self.address = address14
15    def ship_to(self):16        return f"{self.name}, {self.address.label()}"17
18
19c = Customer("Ravi", Address("Pune", "411001"))20print(c.ship_to())21print(isinstance(c, Address))

Output

Ravi, Pune - 411001
False

What this code does

ship_to asks the Address for its label instead of building the text itself.
A Customer is not an Address, so isinstance is False.

Example 3 · A customer has an address

Python

1class Address:2    def __init__(self, city, pin):3        self.city = city4        self.pin = pin5
6    def label(self):7        return f"{self.city} - {self.pin}"8
9
10class Customer:11    def __init__(self, name, address):12        self.name = name13        self.address = address14
15    def ship_to(self):16        return f"{self.name}, {self.address.label()}"17
18
19customer = Customer("Asha", Address("Pune", "411001"))20print(customer.ship_to())

Output

Asha, Pune - 411001

What this code does

Customer keeps an Address object in self.address.
ship_to asks the address for its label instead of rebuilding it.

The Address is a part of the Customer. The Customer never inherits from it.

Why inheriting from a list goes wrong

Suppose you want a stack. Subclassing list is quick, but the stack now also has insert, remove and sort. Callers can break the stack rules.

Python

1class BadStack(list):2    def push(self, item):3        self.append(item)4
5
6stack = BadStack()7stack.push(1)8stack.push(2)9stack.insert(0, 99)   # allowed, but a stack has no bottom insert

Example 4 · A composed stack hides the list

Python

1class Stack:2    def __init__(self):3        self._items = []4
5    def push(self, item):6        self._items.append(item)7
8    def pop(self):9        return self._items.pop()10
11    def size(self):12        return len(self._items)13
14
15s = Stack()16s.push(1)17s.push(2)18print(s.pop())19print(s.size())20print(hasattr(s, "insert"))

Output

2
1
False

What this code does

The list lives in _items, so only push, pop and size are public.
hasattr(s, "insert") is False: callers cannot break the stack order.

A stack has a list. It is not a list. Holding the list privately keeps the public surface small.

Forward the call, swap the part

A Car does not need to be an Engine. It holds one and forwards start() to it. Forwarding a call to a part is called delegation. Because the part is only an attribute, you can replace it later.

Python

1class Engine:2    def start(self):3        return "engine running"4
5
6class Car:7    def __init__(self, engine):8        self.engine = engine9
10    def start(self):11        return "Car: " + self.engine.start()

Example 5 · Delegate to a part and swap it

Python

1class PetrolEngine:2    def start(self):3        return "petrol engine running"4
5
6class ElectricMotor:7    def start(self):8        return "electric motor running"9
10
11class Car:12    def __init__(self, engine):13        self.engine = engine14
15    def start(self):16        return "Car: " + self.engine.start()17
18
19car = Car(PetrolEngine())20print(car.start())21car.engine = ElectricMotor()22print(car.start())

Output

Car: petrol engine running
Car: electric motor running

What this code does

Car.start forwards the call to whatever part it holds.
Assigning a new car.engine changes behaviour without a new class.

Inheritance fixes the parent when you write the class. Composition lets you choose the part when you create or change the object.

Next step

Check your understanding

10 quick questions

1class Employee:2 def __init__(self, name):3 self.name = name4 5 def role(self):6 return "Employee"7 8 9class Manager(Employee):10 def role(self):11 return "Manager"12 13 14m = Manager("Asha")15print(m.name, m.role())16print(isinstance(m, Employee))

Has-a means composition

Composition means building an object from other objects it holds as attributes (a has-a relationship). The whole delegates work to its parts instead of inheriting from them.

A Customer is not an Address. A Customer has an Address. So the Customer keeps an Address object in an attribute and asks it for help.

1class Address:2 def __init__(self, city, pin):3 self.city = city4 self.pin = pin5 6 def label(self):7 return f"{self.city} - {self.pin}"8 9 10class Customer:11 def __init__(self, name, address):12 self.name = name13 self.address = address14 15 def ship_to(self):16 return f"{self.name}, {self.address.label()}"17 18 19c = Customer("Ravi", Address("Pune", "411001"))20print(c.ship_to())21print(isinstance(c, Address))

1class Address:2 def __init__(self, city, pin):3 self.city = city4 self.pin = pin5 6 def label(self):7 return f"{self.city} - {self.pin}"8 9 10class Customer:11 def __init__(self, name, address):12 self.name = name13 self.address = address14 15 def ship_to(self):16 return f"{self.name}, {self.address.label()}"17 18 19customer = Customer("Asha", Address("Pune", "411001"))20print(customer.ship_to())

1class Stack:2 def __init__(self):3 self._items = []4 5 def push(self, item):6 self._items.append(item)7 8 def pop(self):9 return self._items.pop()10 11 def size(self):12 return len(self._items)13 14 15s = Stack()16s.push(1)17s.push(2)18print(s.pop())19print(s.size())20print(hasattr(s, "insert"))

1class Engine:2 def start(self):3 return "engine running"4 5 6class Car:7 def __init__(self, engine):8 self.engine = engine9 10 def start(self):11 return "Car: " + self.engine.start()

1class PetrolEngine:2 def start(self):3 return "petrol engine running"4 5 6class ElectricMotor:7 def start(self):8 return "electric motor running"9 10 11class Car:12 def __init__(self, engine):13 self.engine = engine14 15 def start(self):16 return "Car: " + self.engine.start()17 18 19car = Car(PetrolEngine())20print(car.start())21car.engine = ElectricMotor()22print(car.start())