Introduction to OOP Principles

Study Notes

Object-Oriented Programming (OOP) is a programming paradigm using objects and classes to structure software development.
Focuses on four core principles: Encapsulation, Inheritance, Polymorphism, and Abstraction.

Encapsulation:
- Bundles data (fields) and methods that operate on the data within a single unit called a class.
- Allows data hiding, restricting access to specific details of the object's state.
- Easier to manage and protect the integrity of the data.
Inheritance:
- Enables a new class (subclass) to inherit attributes and methods from an existing class (superclass).
- Promotes code reuse and establishes a relationship between parent and child classes.
Polymorphism:
- Allows objects of different classes to be treated as objects of a common superclass.
- Facilitates method overriding and method overloading, providing flexibility and extensibility in the code.
Abstraction:
- Hides complex implementation details and shows only essential features of the object.
- Simplifies coding by enabling developers to focus on interactions at a higher level.

Classes:
- A blueprint for creating objects.
- Defines properties (fields) & behaviors (methods) that objects created from the class will possess.
Objects:
- An instance of a class.
- Represents a specific example of the class, with a set of values for the properties defined in the class.

Constructors:
- Special methods used to initialize new objects.
- Set object's initial state by assigning values to its fields.
Destructors:
- Methods called when an object is about to be destroyed or deallocated.
- While Java uses garbage collection for memory management, other languages might use destructors for resource cleanup.

Method Overloading:
- Occurs when multiple methods have the same name but differ in parameter type or number within the same class.
- Allows different functionalities based on input parameters.