Four Pillars of OOPs (Object Oriented Programming)

Introduction to OOP

Object-Oriented Programming (OOP) has emerged as a powerful paradigm in the ever-changing world of software development, revolutionizing how we design and build programs. With its emphasis on objects, encapsulation, and reusability, OOP offers a systematic approach to software development that encourages modularity, flexibility, and ease of maintenance. In this section, we will look at the underlying notions of OOP and why it has become such an important part of modern software development.

Benefits of OOP:

Developers can gain various benefits by using OOP principles, including:

• Modularity: OOP fosters the division of complicated systems into smaller, manageable modules, which improves code organization and understanding.
• Reusability: OOP allows developers to reuse classes and objects across projects, saving time and effort.
• Maintenance: The modularity and encapsulation of OOP make it easier to maintain and update code, reducing the impact of changes.
• Scalability: Because of OOP's hierarchical structure and inheritance, developers can extend and modify code without affecting the entire system.

The Four Pillars of OOPs

Object-Oriented Programming (OOP) has developed as a powerful paradigm in programming, facilitating the construction of resilient and scalable software systems. OOP enables developers to organize code logically and efficiently, improving code reuse, maintainability, and overall software quality. At the heart of OOP are the Four Pillars, which serve as the framework for developing well-structured, modular programs. This section will examine the Four Pillars of OOP and their significance in real-world situations.

1. Abstraction

Abstraction is breaking down complex systems into manageable and reusable components to simplify them. It enables us to construct classes and objects that accurately replicate real-world entities while disregarding superfluous features. We can create more efficient and maintainable software by focusing on the essentials. Abstraction in OOP is accomplished through the usage of abstract classes and interfaces. Consider the following scenario: We have an abstract base class called Shape, which declares a pure virtual function calculateArea(), used to calculate the area of various forms. Rectangle and Circle are derived classes that inherit from the Shape class and provide their implementations of the calculateArea() function.

Example 1 - Abstract Class:

Example 2 - Interface:

Consider an interface named Drawable, which defines a contract for things that can be drawn. The Circle class implements the Drawable interface by implementing a draw() function.

2. Encapsulation

Encapsulation groups data and methods within a class to provide a protective barrier over internal implementation details. It allows the construction of objects that encapsulate data and reveal only the methods or interfaces required for interaction with the outside world. This method encourages information concealment by prohibiting direct access to an object's internal state.

Example 1

Consider the following example to grasp encapsulation in practice better. Assume we're creating a banking system and need a class representing a bank account. We want to encapsulate the account balance and give ways for depositing, withdrawing, and retrieving it.

3. Inheritance

Inheritance creates an "is-a" relationship between classes by allowing a derived or child class to inherit characteristics from a parent or base class. This relationship allows the derived class to access and utilize the base class's properties and methods, boosting code reuse and decreasing redundancy.

Example

Consider the following example to see inheritance in action. We'll start with a base class called Shape, followed by two derived classes called Circle and Rectangle, which will inherit from the Shape class. The Shape class will share characteristics and methods the circle and the rectangle share.

The Circle and Rectangle classes in the preceding code inherit from the Shape class via the public access specifier. This option allows derived classes to access the base class's protected members. The Shape class defines common properties (width and height) and methods (setDimensions and displayDimensions) that derived classes can use.

We can now build Circle and Rectangle objects and use their inherited properties and methods. :

4. Polymorphism

Polymorphism, derived from the Greek words "poly" (many) and "morph" (shape), refers to an object's ability to take on numerous forms or behaviors. Polymorphism in the context of OOP allows objects of different kinds to be treated consistently when they share a common superclass.

Example:

Consider a basic example involving several forms. We have a base class called Shape and two subclasses called Rectangle and Circle. Each subclass derives from the 'Shape' class and implements a common behavior known as area(). The code is as follows:

The output of the program will be: