Understanding Object-Oriented Programming with Java

 Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects, which contain data (attributes) and behavior (methods). Java is an object-oriented language, meaning it heavily relies on OOP principles.

---

🔹 Four Pillars of OOP

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

Let's go through each one with examples.

---

1️⃣ Encapsulation (Data Hiding)

Encapsulation is the process of hiding data and restricting direct access to it. Instead, data is accessed via getter and setter methods.

Example:

java
class Person {
    private String name;  // Private variable (hidden from outside)
    
    // Getter method
    public String getName() {
        return name;
    }
    
    // Setter method
    public void setName(String newName) {
        this.name = newName;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("Nahom");  // Setting value
        System.out.println(p.getName());  // Getting value
    }
}

✔️ Benefits: Protects data from unauthorized access and maintains integrity.

---

2️⃣ Abstraction (Hiding Implementation Details)

Abstraction is the concept of hiding complex logic and showing only the relevant details.

Example using Abstract Class:

java
abstract class Animal {
    abstract void makeSound();  // Abstract method (must be implemented)
    
    public void sleep() {
        System.out.println("Sleeping...");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Output: Bark! Bark!
        dog.sleep();      // Output: Sleeping...
    }
}

✔️ Benefits: Reduces complexity and improves code readability.

---

3️⃣ Inheritance (Code Reusability)

Inheritance allows a class to inherit properties and methods from another class using the extends keyword.

Example:

java
class Vehicle {
    int speed = 0;
    
    public void accelerate() {
        speed += 10;
        System.out.println("Speed: " + speed);
    }
}

class Car extends Vehicle {  // Car inherits from Vehicle
    public void honk() {
        System.out.println("Beep Beep!");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.accelerate();  // Output: Speed: 10
        myCar.honk();        // Output: Beep Beep!
    }
}

✔️ Benefits: Reduces code duplication and promotes reusability.

---

4️⃣ Polymorphism (Multiple Forms of a Method)

Polymorphism allows one interface to have multiple implementations.

1️⃣ Method Overriding (Run-time Polymorphism)

A subclass overrides a method from its superclass.

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

class Cat extends Animal {
    public void makeSound() {  // Overriding method
        System.out.println("Meow Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Cat();
        myAnimal.makeSound();  // Output: Meow Meow!
    }
}

✔️ Benefits: Enables dynamic method dispatch (flexible code behavior).

---

2️⃣ Method Overloading (Compile-time Polymorphism)

A class can have multiple methods with the same name but different parameters.

java
class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        MathUtils math = new MathUtils();
        System.out.println(math.add(5, 10));       // Output: 15
        System.out.println(math.add(5, 10, 20));   // Output: 35
    }
}

✔️ Benefits: Improves readability and usability.

---

🔹 Summary of OOP Concepts in Java

Concept	Description	Example
Encapsulation	Hides data and restricts access	Private variables with getter/setter methods
Abstraction	Hides implementation details and shows only functionality	Abstract classes and interfaces
Inheritance	Allows one class to inherit from another	class Car extends Vehicle {}
Polymorphism	One method behaves differently in different classes	Method Overloading & Overriding

---

📌 Real-World Example: Bank System

Imagine a bank system with OOP principles:

java
abstract class Account {
    double balance;
    
    public Account(double balance) {
        this.balance = balance;
    }
    
    public void deposit(double amount) {
        balance += amount;
        System.out.println("Deposited: " + amount);
    }
    
    abstract void withdraw(double amount);  // Abstract method
}

class SavingsAccount extends Account {
    public SavingsAccount(double balance) {
        super(balance);
    }

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            System.out.println("Withdrew: " + amount);
        } else {
            System.out.println("Insufficient funds");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SavingsAccount acc = new SavingsAccount(1000);
        acc.deposit(500);    // Output: Deposited: 500
        acc.withdraw(300);   // Output: Withdrew: 300
    }
}

---

🔹 Conclusion

OOP makes Java programs modular, reusable, and scalable. Mastering these concepts will help you build efficient and maintainable applications.