---
title: Class inheritance (extend) and overriding (en)
description: A complete example of Python class inheritance (extend) and method overriding — Manager inherits from Employee and overrides get_employee_info, and Department manages staff with class methods.
url: "https://aaronchan.com/kb/class-inheritance/"
updated: "2026-09-15"
category: "Code-Python (en)"
---

# Class inheritance (extend) and overriding (en)

This example shows how a class extends and overrides methods. Employee is the base class. Manager inherits from it, adds a department field, and rewrites get_employee_info into its own version. Department uses class methods to manage the whole team of staff.

 Copy

```
class Employee:

    numberOfEmployee=0

    def __init__(self, name, salary, city):
        self.name = name
        self.salary = salary
        self.city = city
        Employee.numberOfEmployee += 1

    def getInfo(self):
        return (f'name:{self.name}, salary:{self.salary}, city:{self.city}')

    def getSalary(self):
        return self.salary

    def get_employee_info(self):
        return f'{self.name}, Salary:{self.salary}, City:{self.city}'

    def __del__ (self):
        Employee.numberOfEmployee -=1

class Manager(Employee):
    #extend class
    def __init__(self, name, salary, city, department):
        super(). __init__(name, salary, city)
        self.department = department
    #override
    def get_employee_info(self):
        return f'{self.name} (Manager of {self.department}, City: {self.city})'

class Department:
    companyName = 'TTL'

    def __init__(self, name):
        self.name=name
        self.employee=[]
        self.budget=0

    @classmethod
    def getCompanyName(cls):
        return cls.companyName

    def setBudget(self, amount):
        self.budget=amount
        return

    def getBudget(self):
        return self.budget

    def addEmployee (self, staff):
        self.employee.append(staff)

    def getEmployee(self):
        return self.employee

    def getTotalStaffCost(self):
        TotalStaffCost=0
        return sum([employee.salary for employee in self.employee])
        # for i in self.employee:
        #     TotalStaffCost += i.salary
        # return TotalStaffCost

    def getSalaryAverage(self):
        return self.getTotalStaffCost()/len(self.employee)

    def get_employee_info(self):
        return f'{self.name}, {len(self.employee)} employee(s)'

    @classmethod
    def getNumberOfEmployee(cls):
        return cls.numberOfEmployee

    @classmethod
    def setCompanyName (cls, name):
        cls.companyName = name

emp1 = Employee('Peter', 10000, 'KT')
emp2 = Employee('John', 15000, 'HK')

employees = []
employees.append(emp1)
employees.append(emp2)
# print(employees[0].getInfo())
employees.append(Employee('Mary', 50000, 'KT'))

totalSalary=0
for i in employees:
    totalSalary += i.getSalary()
print (f'Total Salary= {totalSalary}')
print (f'Average Salary= {totalSalary/len(employees)}')

hr=Department('HR')
it=Department('IT')

hr.addEmployee(Employee('Peter', 10000, 'KT'))
hr.addEmployee(Employee('John', 15000, 'KT'))
hr.addEmployee(Manager('ManagerWong', 30000, 'KT', 'HR Department'))

for employee in hr.employee:
    print(employee.get_employee_info())
```

**output:**

```
Total Salary= 75000
Average Salary= 25000.0
Peter, Salary:10000, City:KT
John, Salary:15000, City:KT
ManagerWong (Manager of HR Department, City: KT)
```

- Inheritance (extend): put the parent class in the parentheses — class Manager(Employee) — and Manager automatically gets all of Employee's attributes and methods, no rewriting needed.
- Overriding: Manager defines a same-named get_employee_info with different content. Call it on a Manager object and the Manager version runs (see the last line of the output — the format is different).
- Class method (@classmethod): the first parameter is cls (the class itself), so you can use it without creating an object, e.g. getCompanyName.
- Class variable: numberOfEmployee belongs to the class level and is shared by all objects. __init__ increments it and __del__ decrements it, tracking the total headcount.