Object-oriented programming (OOP) is based on several key principles designed to promote

code reusability, scalability, and maintainability. The core principles of OOP include:

Encapsulation:

Definition: Encapsulation refers to the bundling of data (attributes) and methods (functions or
procedures) that operate on the data into a single unit, called an object. It can be used in data
hiding by restricting direct access to some of an object's components, which is a means of
preventing unintended interference and misuse of the methods and data.

Purpose: It hides the internal state of the object and requires all interaction to be performed
through an object's methods, enhancing modularity and reducing complexity.

Abstraction:

Definition: Abstraction is the concept of hiding the complex implementation details and showing
only the necessary features of an object. It involves creating simple models that represent more
complex underlying code and data.

Purpose: It simplifies the process of handling complexity by allowing the programmer to work
with higher-level concepts without needing to understand all the intricate details.

Inheritance:

Definition: Inheritance is a mechanism wherein a new class (called a subclass or derived class) is
created from an existing class (called a superclass or base class). The subclass inherits attributes
and methods of the superclass but can also have additional attributes and methods or override
existing ones.

Purpose: It promotes code reusability and establishes a natural hierarchy between classes,
making it easier to create and maintain an organized codebase.

Polymorphism:

Definition: Polymorphism is one of the core concepts of object-oriented programming

(OOP) that describes situations in which something occurs in several different forms. In
computer science, polymorphism describes the concept that you can access objects of different
types through the same interface. Each type can provide its own independent implementation of
this interface.

Purpose: It provides flexibility and the ability to define one interface and have multiple
implementations, thereby enabling code to be more generic and adaptable to different data types
or classes.
These principles collectively enable OOP to create systems that are modular, scalable, and easier
to understand and maintain.