Four Pillars Java

 Java, as an object-oriented programming language, is built upon four fundamental principles known as the Four Pillars of OOP (Object-Oriented Programming). These pillars define how Java structures and manipulates data efficiently. The four pillars are:

1. Encapsulation
2. Abstraction
3. Inheritance
4. Polymorphism

Each of these plays a crucial role in designing modular, scalable, and maintainable applications. Let’s explore them in detail with code examples.

1. Encapsulation

Encapsulation is the mechanism of restricting direct access to some components of an object and only exposing what is necessary. This is achieved using access modifiers like private, protected, and public.

Importance of Encapsulation:

• Hides implementation details from the outside world
• Improves security by preventing unintended modifications
• Enhances maintainability and reusability

Example:

class BankAccount {
    private double balance; // Encapsulated data


public BankAccount(double balance) {
        this.balance = balance;
    }
    public double getBalance() { // Getter method
        return balance;
    }
    public void deposit(double amount) { // Method with controlled access
        if (amount > 0) {
            balance += amount;
        }
    }
}
public class EncapsulationDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(5000);
        account.deposit(2000);
        System.out.println("Current Balance: " + account.getBalance());
    }
}

2. Abstraction

Abstraction is the concept of hiding complex implementation details and exposing only the relevant parts to the user. It is primarily achieved using abstract classes and interfaces.

Importance of Abstraction:

• Reduces complexity by hiding unnecessary implementation details
• Improves code maintainability
• Enhances flexibility and scalability

Example:

abstract class Vehicle {
    abstract void start(); // Abstract method (no implementation)
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car is starting with key ignition.");
    }
}
public class AbstractionDemo {
    public static void main(String[] args) {
        Vehicle myCar = new Car();
        myCar.start();
    }
}

3. Inheritance

Inheritance allows a class to acquire the properties and behaviors of another class. The existing class is called the parent (superclass), while the new class is the child (subclass).

Importance of Inheritance:

• Promotes code reusability
• Helps in hierarchical classification
• Reduces code duplication

Example:

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}
public class InheritanceDemo {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound(); // Calls overridden method in Dog class
    }
}

4. Polymorphism

Polymorphism enables a single action to behave differently based on the context. It is mainly divided into compile-time (method overloading) and runtime polymorphism (method overriding).

Importance of Polymorphism:

• Enhances code flexibility and scalability
• Reduces coupling and increases maintainability
• Provides better readability and reusability

Example (Method Overloading — Compile-time Polymorphism):

class MathOperations {
    int add(int a, int b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        MathOperations obj = new MathOperations();
        System.out.println("Sum: " + obj.add(5, 10));
        System.out.println("Sum: " + obj.add(5, 10, 15));
    }
}

Example (Method Overriding — Runtime Polymorphism):

class Parent {
    void show() {
        System.out.println("Parent class method");
    }
}
class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child class method");
    }
}
public class RuntimePolymorphismDemo {
    public static void main(String[] args) {
        Parent obj = new Child(); // Upcasting
        obj.show(); // Calls the overridden method in Child class
    }
}

Conclusion

The Four Pillars of Java — Encapsulation, Abstraction, Inheritance, and Polymorphism — are fundamental to writing efficient, reusable, and maintainable Java applications. Mastering these concepts allows developers to build robust and scalable systems while following the best object-oriented programming practices.

Understanding these principles is crucial for Java developers, as they are commonly asked in interviews and extensively used in real-world enterprise applications.