Understanding the four pillars of object-oriented programming

Object-oriented programming (OOP) has been a cornerstone of modern software development, and understanding its principles is key for anyone aiming to build scalable and maintainable applications. This article will walk you through the four core concepts of OOP—encapsulation, abstraction, inheritance, and polymorphism. Exploring these pillars will help you better understand how OOP structures code to simplify development.

The basics: Why object-oriented programming?

Before delving into the four core principles, it’s essential to understand why OOP was developed in the first place. Before OOP, procedural programming was the norm. Procedural programming divides programs into a set of functions and variables. Functions operate on the data stored in variables, and the program flows sequentially.

While simple and easy to learn, procedural programming has its limitations. As programs became more complex, programmers struggled with “spaghetti code”—unstructured, tangled code where changes to one function could inadvertently break others. OOP emerged as a solution to this problem, grouping related variables (properties) and functions (methods) into objects, making code easier to manage and maintain.

Introduction to object-oriented programming (OOP) and its challenges

Encapsulation: Bundling properties and methods together

The first pillar of OOP, encapsulation, is about grouping related properties and methods into a single entity called an object. An object encapsulates its data (properties) and the operations that can be performed on that data (methods).

For example, consider a car. A car object might have properties like make, model, and color and methods like start, stop, and move. By bundling these related components into a single unit, encapsulation ensures the object can act independently.

In programming terms, encapsulation helps to organize data and functionality within objects, reducing redundancy and keeping your code simpler. This separation of concerns also makes your code easier to maintain.

Encapsulation illustrated with the example of a car object, showing properties and methods grouped together.

Encapsulation example: Procedural code vs OOP code

Consider a procedural implementation where you have separate variables for baseSalary, overtime, and rate, and a function calculateWage operating on these variables. The function has multiple parameters, leading to complexity. In contrast, with OOP, you could create an Employee object with properties like baseSalary, overtime, and rate, and a method like getWage. The method would internally use the object’s properties, eliminating the need for parameters.

Benefits of encapsulation:

1. Reduced complexity: Objects group related elements together.
2. Simpler methods: Functions within objects have fewer (or no) parameters, making them easier to work with.
3. Less redundancy: Objects allow you to reuse code in multiple places or programs.

As Uncle Bob famously said, "The best functions are those with no parameters." Encapsulation helps achieve this goal by integrating data and behavior into cohesive units.

Abstraction: Simplifying complexity

Abstraction is the second pillar of OOP. It’s about hiding unnecessary details and showing only the essential features of an object. Think of a DVD player: it has a complex internal circuitry, but users only interact with its external buttons like Play or Pause. The complexity is abstracted away from the user.

In programming, abstraction means you expose only the parts of an object that are essential for external usage while hiding the rest. This is achieved by setting certain properties or methods as private or protected. For example, you might expose a play method for a media player object but keep its complex inner implementation hidden.

Illustration of abstraction with a DVD player's buttons and internal logic.

Benefits of abstraction

1. Simplified interface: The users of an object interact only with the essentials, making the object easier to use.
2. Reduced impact of change: Changes to the internal details of an object (e.g., private methods) don’t impact the rest of the code. For example, changing how a play method works internally doesn’t affect the code that calls play.

By leveraging abstraction, you make your code more modular and easier to maintain, allowing you to focus on the external functionality without worrying about inner complexities.

Inheritance: Reusing and extending code

The third pillar of OOP, inheritance, is about eliminating redundant code by enabling new objects to inherit properties and methods from existing ones. A classic example in web development involves HTML elements.

Almost every HTML element (like text boxes, drop-downs, or checkboxes) shares common properties like hidden or innerHTML and methods like click or focus. Rather than redefining these for every element type, you define them once in a base class (e.g., HTMLElement). Other specific objects, like TextBox or DropDown, inherit from the base class.

Inheritance with HTML elements example: sharing common properties and methods.

Benefits of inheritance

1. Code reuse: Common functionality can be defined once in a base class and shared across derived classes.
2. Reduced redundancy: Classes that extend the base can focus on their unique features without duplicating shared code.

By using inheritance, developers can reduce the repetition of common properties or methods, making code more streamlined and easier to extend.

Polymorphism: Many forms, one interface

The final pillar of OOP is polymorphism, which means “many forms.” Polymorphism enables a single interface to represent different underlying forms (objects). This is particularly useful for eliminating long if-else or switch statements.

For example, consider rendering HTML elements. Each type of element (TextBox, DropDown, CheckBox) needs to be rendered differently. In a procedural approach, rendering logic might involve a long switch statement that checks the type of each object.

With polymorphism, each element implements its own render method. When you call the render method on an object, the appropriate method for that object type is automatically executed. This removes the need for long conditional statements and simplifies the code.

Polymorphism illustrated with HTML elements having their own render methods.

Why polymorphism matters

1. Cleaner code: Replace lengthy conditionals with a single call to a polymorphic method.
2. Extendable design: Adding support for new object types is easier, as each type handles its own behavior.

How the four pillars work together

Combining these four core concepts, developers can create modular, reusable, and maintainable code structures. Here’s how these principles reinforce each other in OOP:

1. Encapsulation groups related functionality, reducing complexity.
2. Abstraction hides unnecessary details, exposing only essential features.
3. Inheritance eliminates redundant code by sharing common behavior.
4. Polymorphism simplifies code by handling diverse behaviors via a unified interface.

Together, these pillars provide a strong foundation for building scalable software systems.

Recap of the four pillars and their benefits in OOP.

Conclusion: Elevate your programming with OOP

Object-oriented programming is more than just a design methodology—it’s a paradigm that empowers developers to write clean, maintainable, and scalable code. By mastering encapsulation, abstraction, inheritance, and polymorphism, you can organize your code better, reduce redundancy, and handle complexity with ease.

If you’re looking to dive deeper into OOP, consider enrolling in Mosh Hamedani’s online course on OOP with JavaScript, where you’ll explore these concepts in even greater depth. And don't forget to subscribe to his YouTube channel for more programming tutorials.

Thank you for reading, and happy coding!