Inheritance

Inheritance lets a new class, called a subclass or child class, derive attributes and methods from an existing class, called a superclass or parent class. This models 'is-a' relationships and enables code reuse: instead of rewriting shared behavior, a subclass extends the parent and adds or modifies only what makes it different. Python supports single inheritance (one direct parent, the focus of this lesson) as well as multiple inheritance, but the core mechanics are best understood through the single-inheritance case first.

A subclass is declared by listing the parent class in parentheses: class Dog(Animal):. Inside the subclass's __init__, calling super().__init__(...) invokes the parent class's constructor, letting the subclass reuse the parent's initialization logic instead of duplicating it, while still adding its own subclass-specific attributes afterward. Method overriding occurs when a subclass defines a method with the same name as one in its parent, replacing the parent's implementation for instances of the subclass; the subclass method can still call the parent's version explicitly via super().method_name() if it wants to extend rather than fully replace the behavior. It is important to distinguish overriding from overloading: overloading means defining multiple methods with the same name but different parameter signatures (different number or type of arguments) within the same class, and Python does not support true overloading — if you define two methods with the same name in one class, the second definition simply replaces the first. Python instead achieves overloading-like flexibility through default argument values, *args/**kwargs, or the functools.singledispatch decorator, but that is a distinct mechanism from what languages like Java call method overloading.

Dog(Animal) establishes single inheritance: Dog has exactly one direct parent, Animal. Inside Dog.__init__, super().__init__(name, sound="Woof") calls Animal.__init__, so self.name and self.sound are set using the parent's logic; Dog then adds its own self.breed afterward, avoiding duplication of the name/sound assignment logic. Dog.speak is an override: it has the same name and signature as Animal.speak, but a completely different body, and Python resolves rex.speak() to Dog.speak because Dog is the more specific (derived) type. Notice Dog.speak calls super().speak() internally, so it extends rather than fully discards the parent's behavior. describe() is not overridden in Dog, so rex.describe() falls back to Animal.describe, demonstrating inherited (unchanged) behavior. Finally, this example could not demonstrate method overloading, because Python does not support it: defining speak twice in the same class with different parameters would simply mean the later definition silently replaces the earlier one, not that Python dispatches based on argument count or type.