4.1) Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a programming paradigm that uses the concept of “objects” to structure and design software. OOP is based on the principles of abstraction, encapsulation, inheritance, and polymorphism. It allows you to model real-world entities and their relationships in your code, making it more organized, modular, and easier to maintain and extend.

Here’s a detailed explanation of the key concepts of OOP:

1. Classes and Objects

• Class: A class is a blueprint for creating objects. It defines the properties (attributes) and behaviors (methods) that the objects of that class will have. A class acts as a template from which objects are created.
• Object: An object is an instance of a class. It represents a real-world entity and encapsulates both data (attributes) and the operations (methods) that can be performed on that data.

2. Abstraction

Abstraction is the process of simplifying complex reality by modeling classes based on relevant attributes and behaviors. It allows you to focus on the essential aspects of an object while ignoring the unnecessary details.

3. Encapsulation

Encapsulation refers to the practice of bundling data (attributes) and the methods that operate on that data into a single unit, i.e., the class. It hides the internal implementation details of an object from the outside world, providing controlled access through public interfaces (public methods).

4. Inheritance

Inheritance allows you to create a new class (subclass or derived class) based on an existing class (base class or parent class). The subclass inherits attributes and methods from the base class, and it can also override or extend them.

5. Polymorphism

Polymorphism means “many forms” and refers to the ability of different objects to respond to the same method call in their own unique way. Polymorphism is achieved through inheritance and method overriding. It enables you to write more flexible and reusable code.

6. Example

Let’s consider a simple example of a Car class in C++ to illustrate the concepts:

#include <iostream>
#include <string>

class Car {
private:
    std::string brand;
    int year;

public:
    Car(std::string b, int y) : brand(b), year(y) {}

    void startEngine() {
        std::cout << "Engine started!" << std::endl;
    }

    void stopEngine() {
        std::cout << "Engine stopped!" << std::endl;
    }

    void displayInfo() {
        std::cout << "Brand: " << brand << ", Year: " << year << std::endl;
    }
};

int main() {
    Car myCar("Toyota", 2022);

    myCar.displayInfo();
    myCar.startEngine();
    myCar.stopEngine();

    return 0;
}

Output:

Brand: Toyota, Year: 2022
Engine started!
Engine stopped!

In this example:

• Car is the class.
• myCar is an object of the Car class.
• brand and year are attributes.
• startEngine(), stopEngine(), and displayInfo() are methods.

OOP promotes the organization of code, modularity, and reusability. By defining classes, you can model real-world entities and their behaviors, leading to more structured and maintainable code. It’s important to understand the fundamental principles of OOP to design effective and robust software systems.