Introduction

When we talk about modern software development, Object-Oriented Programming (OOP) is at the core of building maintainable, scalable, and reusable applications. Java, being one of the most widely used languages in enterprise development, is built around OOP.

In this post, we’ll explore the four fundamental principles of OOP with real-world analogies and Java code examples.

1. Encapsulation – Hiding the Details

Definition: Idea of encapsulation is to surround the attributes and behaviour of object , keeping related functionality together and to protect them from outside world. Encapsulation is the practice of bundling data (fields) and methods (behavior) into a single unit, typically a class. It restricts direct access to internal state and only exposes controlled access via getters and setters.

Analogy: Think of a capsule medicine – the ingredients are hidden inside, but you can take the capsule safely without worrying about what’s inside. Java Example:

public class BankAccount {

    private double balance;  // private field

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // Controlled access
    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

✅ Benefits: Data protection, controlled access, easier maintenance.

2. Inheritance – Reusing Existing Code

Definition: Inheritance describes IS A Relationship. Inheritance allows a class to acquire properties and behavior from another class (using the extends keyword in Java).

Analogy: A Car(derived) is a Vehicle(Base). Corona(derived) is a Virus(Base).

// Parent class
class Vehicle {
    public void start() {
        System.out.println("Vehicle starting...");
    }
}

// Child class inherits Vehicle
class Car extends Vehicle {
    public void playMusic() {
        System.out.println("Playing music in the car");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();       // Inherited method
        car.playMusic();   // Child-specific method
    }
}

✅ Benefits: Code reuse, hierarchical classification, reduces duplication.

3. Polymorphism – One Interface, Many Forms

Definition: Polymorphism allows objects to be treated as instances of their parent class, enabling flexibility in method invocation.

Two types:

• Compile-time polymorphism (Method Overloading) - Static polymorphism - Writing multiple methods with the same name but with different sets of parameters (or order of parameters) so that the appropriate method gets invoked based on the parameters passed.

• Runtime polymorphism (Method Overriding) - Dynamic polymorphism - Child class implements a method that is already present in the parent class, resulting in the child method being invoked.

Analogy: A person can be a student at school, a customer at a shop, or an employee at work — one entity, many roles.

Java Example (Runtime Polymorphism):

class Animal {
    public void sound() {
        System.out.println("Some generic sound...");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark!");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound();  // Prints "Bark!"
    }
}

✅ Benefits: Flexibility, easier to extend, cleaner code.

4. Abstraction – Hiding Implementation Details

Definition: Abstraction focuses on exposing only essential features of an object while hiding the implementation. Achieved using abstract classes and interfaces in Java.

Analogy: When you drive a car, you only use the steering wheel and pedals — you don’t need to know how the engine works.

Java Example:

// Abstract class
abstract class Payment {
    public abstract void pay(double amount);
}

// Concrete classes
class CreditCardPayment extends Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using Credit Card");
    }
}

class PayPalPayment extends Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using PayPal");
    }
}

✅ Benefits: Cleaner design, contract-driven development, flexible implementations. Conclusion

The four pillars of OOP — Encapsulation, Inheritance, Polymorphism, and Abstraction — form the backbone of Java and enterprise application development.

• Encapsulation → Data protection

• Inheritance → Code reuse

• Polymorphism → Flexibility

• Abstraction → Simplification

By mastering these principles, developers can write cleaner, reusable, and scalable applications.