What is the difference between inheritance and composition?

Inheritance creates an 'is-a' relationship where a subclass extends a parent class's implementation directly. Composition creates a 'has-a' relationship, where an object is built by combining other objects that each provide specific functionality, which is generally considered more flexible.

Can a class inherit from multiple classes?

It depends on the language. C++ supports multiple inheritance directly, but many popular languages like Java, C#, and TypeScript restrict classes to single inheritance while allowing a class to implement multiple interfaces.

Why is deep inheritance considered risky?

Long inheritance chains tightly couple subclasses to the exact implementation of their ancestors, so a change deep in the hierarchy can have unpredictable effects on every descendant class, making the codebase harder to maintain.

What is the diamond problem?

It's an ambiguity that arises when a class inherits from two classes that both inherit from a common ancestor, creating uncertainty about which version of an inherited method should be used. It's a key reason many languages restrict multiple class inheritance.

What does 'favor composition over inheritance' mean?

It's a design guideline suggesting that building objects by combining smaller, focused components is often more flexible and maintainable than relying on deep class inheritance hierarchies.

Programming

Inheritance

BeginnerConcept6.2K learners

Inheritance is an object-oriented programming mechanism that allows a class to acquire the properties and methods of another class, letting a subclass reuse and extend the behavior of a parent (base) class.

#Inheritance #Programming#Concept#Beginner#Polymorphism #Encapsulation #AbstractClass #Interfaces #SoftwareDevelopment#Glossary#SkillVeris

Definition

Overview

Inheritance lets developers model 'is-a' relationships between classes: a `Dog` class can inherit from an `Animal` class because a dog is a kind of animal, automatically gaining `Animal`'s fields and methods while adding or overriding behavior specific to dogs. This is one of the foundational ideas of object-oriented programming and, alongside polymorphism, is what enables a subclass to be used anywhere its parent class is expected. Most mainstream languages support single inheritance, where a class can extend only one direct parent, though a class can still inherit indirectly through a chain of ancestors. Some languages, like C++, support multiple inheritance directly, while others, like Java and TypeScript, restrict classes to single inheritance but allow implementing multiple interfaces instead, sidestepping the ambiguity problems (like the 'diamond problem') that multiple class inheritance can introduce. Inheritance is powerful for code reuse, but overusing it — building deep hierarchies of classes that inherit from classes that inherit from other classes — is a well-known source of fragility, since a change to a base class can ripple unpredictably through every descendant. This has led to the widely cited principle of favoring composition over inheritance: instead of a subclass inheriting behavior, an object can be composed of smaller, focused objects that each provide one piece of functionality, which tends to be more flexible and easier to change safely. Inheritance also interacts with encapsulation: a well-designed base class exposes a clear protected or public interface for subclasses to extend, while keeping its internal implementation details hidden, so subclasses build on stable behavior rather than fragile internals.

Key Concepts

Lets a subclass acquire fields and methods from a parent class
Models 'is-a' relationships between related classes
Most languages support single inheritance of classes, plus multiple interfaces
Subclasses can override or extend inherited behavior
Deep inheritance chains can create fragile, hard-to-change code
'Composition over inheritance' is a common alternative design principle
Works closely with polymorphism to enable flexible, extensible code

Use Cases

Modeling natural hierarchical relationships (e.g., Vehicle → Car → ElectricCar)

Reusing common logic across related classes without duplication

Building extensible frameworks with overridable base class behavior

Sharing default implementations across a family of related types

Implementing template-style base classes for consistent structure

Reducing boilerplate in domain models with shared fields and behavior

Structuring UI component hierarchies in some frameworks

Frequently Asked Questions

From the Blog

Programming

Object-Oriented Programming in Python: A Practical Guide

OOP is how Python codebases stay organised as they grow. This guide explains classes, inheritance, encapsulation, and polymorphism with real examples — and tells you honestly when to use OOP and when plain functions are the better choice.