Inheritance, Polymorphism, and Encapsulation: Object-Oriented Design Patterns

A Deep Dive into Inheritance, Polymorphism, and Encapsulation: The Pillars of Object-Oriented Design

Patrick Karsh
3 min readJun 28, 2023

In the world of software engineering, there exist numerous approaches to writing code. Among the most prevalent is Object-Oriented Programming (OOP), a design paradigm centered around the concept of “objects,” which are instances of classes, often likened to real-world entities. The four key principles of OOP are inheritance, polymorphism, encapsulation, and abstraction. In this article, we will deep dive into the first three, exploring their inner workings, implications, and real-world examples.

Understanding Inheritance

Inheritance is a cornerstone principle of OOP that promotes code reusability and maintains an organized, hierarchical structure. In essence, it allows one class (the “child” or “subclass”) to inherit the attributes and methods of another class (the “parent” or “superclass”).

Consider a real-world example. Let’s say you’re designing a game featuring various kinds of vehicles. You could create a base class called “Vehicle,” with attributes like speed and color and methods like accelerate() and brake(). Next, you could define subclasses like “Car,” “Bike,” or “Boat” that inherit these common features from the Vehicle class, while also introducing their own unique attributes and methods.

Inheritance enables subclasses to leverage and extend the functionality provided by their superclass, promoting code reusability. It adheres to the DRY principle (Don’t Repeat Yourself), which is a fundamental guideline in software development to reduce the repetition of code.

Exploring Polymorphism

Polymorphism is derived from two Greek words: “poly,” meaning many, and “morph,” meaning forms. In OOP, it describes the concept that objects of different types can be accessed through the same interface, each responding differently to the same message or function call.

The principle of polymorphism offers two primary forms: compile-time (overloading) and runtime (overriding). Overloading allows functions or operators to have different implementations based on the input parameters’ type or number. Overriding, on the other hand, lets a subclass provide a specific implementation of a method that’s already present in its parent class.

Imagine a base class “Shape” with a method calculateArea(). Subclasses like “Circle,” “Square,” and “Triangle” would each have their own implementation of calculateArea(), appropriate to their specific shapes. When the method is invoked on a shape object, the correct version executes based on the object’s actual instantiated class, even if the reference is of the base class type.

Polymorphism is vital in providing flexibility and extensibility to code, allowing complex systems to scale and evolve over time while preserving readability and simplicity.

The Power of Encapsulation

Encapsulation, the third pillar of OOP, focuses on hiding the internal states and functionality of objects and exposing only what’s necessary. It’s an approach that conceals the complexities of a system and provides a simplified interface for interaction.

Using encapsulation, a class’s internal data (attributes) and methods can be hidden from outside interference, accessible only through methods known as getters (accessors) and setters (mutators). This mechanism provides control over the data’s integrity and prevents unauthorized modifications.

Take a BankAccount class, for instance. It may have attributes like accountNumber and balance. These are sensitive data and should not be directly accessible. Instead, they can be encapsulated, and methods such as deposit(), withdraw(), and getBalance() can be used to interact with the account. This approach not only secures the data but also provides a clear and safe interface to interact with.

Encapsulation also promotes modularity and separation of concerns, where each object is responsible for a specific set of

functionalities. It supports maintainability and adaptability, as internal implementations can be modified without impacting the external interface.


Inheritance, polymorphism, and encapsulation form the bedrock of Object-Oriented Programming, contributing to robust, reusable, and maintainable software design. While these principles can initially seem abstract and complex, they mimic many facets of how we categorize and interact with the world around us, making OOP a highly intuitive approach for many developers. Understanding these principles can significantly enhance your programming abilities and set a strong foundation for tackling complex software design problems. Remember, these are tools in your toolbox — knowing when and how to apply them is an art and science that comes with practice and experience.



Patrick Karsh

NYC-based Ruby on Rails and Javascript Engineer leveraging AI to explore Engineering.