Writing Classes in Python

Python uses the class keyword to define a class. The constructor is __init__(self, ...). self refers to the current instance.

class Animal:
    def __init__(self, name, sound):
        self.__name = name     # private attribute
        self.__sound = sound

    def get_name(self):        # getter
        return self.__name

    def speak(self):
        return self.__name + " says " + self.__sound

class Dog(Animal):             # Dog inherits Animal
    def __init__(self, name):
        super().__init__(name, "Woof")  # call parent constructor

    def fetch(self):
        return self.__name + " fetches the ball!"

Using super()

super() calls a method from the parent class. Most commonly used in the subclass constructor to call the parent's __init__ and avoid duplicating initialisation code.

Access Modifiers in Python

Python uses naming conventions rather than strict keywords:

• Public: self.name — accessible everywhere
• Protected: self._name — convention; accessible within class and subclasses
• Private: self.__name — name mangled; not directly accessible outside the class

Getters and Setters

Public methods to read (get) and modify (set) private attributes. Setters can include validation logic:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Amount must be positive")

Class Diagrams (UML)

UML class diagrams show: class name (top), attributes (middle), methods (bottom). Arrows show inheritance (hollow triangle) and association.

• + (plus) = public
• - (minus) = private
• # (hash) = protected

Association, Aggregation, Composition

• Association: one class uses another (e.g. Student uses Library)
• Aggregation: "has a" relationship — parts can exist independently (e.g. Department has Teachers; teachers exist without the department)
• Composition: strong "has a" — parts cannot exist independently (e.g. House has Rooms; rooms don't exist without the house)

Overloading vs Overriding

• Method overriding: subclass replaces a parent's method with its own version
• Method overloading: same method name with different parameter types/counts (Python handles this via default parameters)