In programming, there are different ways to organize your code. One older approach is Procedure-Oriented Programming (POP). Think of it like a recipe. You have a list of steps (procedures or functions) to follow from top to bottom. The main focus is on the actions, and the data is often just passed around from one function to another.

Object-Oriented Programming (OOP), on the other hand, flips this idea. Instead of focusing on the steps, it focuses on the things involved. It bundles data and the functions that operate on that data into single units called objects. This approach models the real world, making code more intuitive, reusable, and easier to manage as programs grow more complex.

So, how do we create these objects? We use a class. A class is not an object itself; it's the blueprint or template for creating objects. Think of a car factory. The engineers create a detailed blueprint for a new car model. This blueprint specifies the properties (like color, engine size) and behaviors (like startEngine(), accelerate()).

The blueprint is the class. Every car that rolls off the assembly line, built according to that blueprint, is an object. Each car has its own specific properties (one is red, another is blue) but shares the same fundamental behaviors defined in the blueprint. For this reason, a class is often called an 'object factory'.

Once the class is defined, you can produce as many Car objects as you need:

Car myCar = new Car(); Car friendsCar = new Car();

Here, myCar and friendsCar are two distinct objects, each an instance of the Car class.

Two core principles of OOP, encapsulation and abstraction, are all about managing complexity. They sound similar, but they solve different problems.

Encapsulation is about bundling data (variables) and the methods that operate on that data into a single unit: the class. It also involves protecting that data from outside interference, a concept known as data hiding. In Java, we use access modifiers like private to prevent direct access to a class's variables. To interact with the data, you must use the public methods the class provides (often called getters and setters).

In the Smartphone class, you can't just write myPhone.batteryLevel = 500;. You have to use the charge() method, which contains logic to ensure the battery level doesn't go above 100. This is the power of encapsulation.

Abstraction, on the other hand, is about hiding implementation details and showing only the essential features. When you use a smartphone, you tap an icon to open an app. You know what will happen, but you don't need to know how the operating system loads the app into memory. The complexity is abstracted away.

The final two pillars of OOP are Inheritance and Polymorphism. They work together to create flexible and reusable code.

Inheritance is the mechanism where a new class (a subclass or child class) acquires the properties and methods of an existing class (a superclass or parent class). This promotes code reusability. Why write the same code twice? If a Motorcycle and a Car both have a model and can startEngine(), you can define these common features in a parent Vehicle class and have both Motorcycle and Car inherit from it.

Polymorphism, which means "many forms," allows us to perform a single action in different ways. In Java, one common way to achieve this is through method overloading. This is when two or more methods within the same class share the same name but have different parameters (either a different number of arguments, or different types of arguments). The compiler knows which one to call based on the arguments you provide.

Method overloading makes your code cleaner. Instead of creating methods like addTwoNumbers(), addThreeNumbers(), and addTwoDoubles(), you can just use add(). The context determines the behavior.

These four principles are the foundation of object-oriented design. Mastering them allows you to write code that is not only functional but also clean, modular, and easy to maintain.