Encapsulation: Detailed Explanation

Encapsulation ek aisa OOP principle hai jisme data members (variables) aur methods ko ek class ke andar bundle kiya jata hai, aur bahar ke direct access se roka jata hai, jo data security aur integrity ke liye zaroori hai.

• Private variables: Data ko private declare karke direct access ko roka jata hai.
• Public getter-setter methods: Data members ko safely access aur modify karne ke liye methods provide kiye jate hain.
• Benefits: Data hiding, code maintainability, improved security, aur modularity.

Encapsulation Example with Explanation

class BankAccount {
    private String accountNumber;
    private double balance;

    // Getter method
    public String getAccountNumber() {
        return accountNumber;
    }

    // Setter method with validation
    public void setAccountNumber(String accNo) {
        if(accNo != null && accNo.length() == 10) {
            this.accountNumber = accNo;
        } else {
            System.out.println("Invalid account number");
        }
    }

    // Getter for balance
    public double getBalance() {
        return balance;
    }

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

    // Withdraw method with condition
    public boolean withdraw(double amount) {
        if(amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        } else {
            System.out.println("Insufficient Balance or Invalid amount");
            return false;
        }
    }
}

public class TestBankAccount {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.setAccountNumber("1234567890");
        System.out.println("Account Number: " + acc.getAccountNumber());

        acc.deposit(5000);
        System.out.println("Balance after deposit: " + acc.getBalance());

        boolean success = acc.withdraw(2000);
        System.out.println("Withdraw success: " + success);
        System.out.println("Balance after withdrawal: " + acc.getBalance());
    }
}

Abstraction: Detailed Explanation

Abstraction mein internal complex details hide karke sirf essential features ko show kiya jata hai, jisse software simpler bana hai. Java me abstraction either abstract classes ya interfaces ke madhyam se achieve hota hai.

• Abstract Classes: Kuch methods declare kiye jate hain bina implementation ke, jo subclasses implement karte hain.
• Interfaces: Completely abstract method ka contract define karte hain.
• Advantages: Flexibility in code, easier maintenance, loose coupling between components.

Abstraction Example with Abstract Class

abstract class Vehicle {
    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car started");
    }
}

public class TestVehicle {
    public static void main(String[] args) {
        Vehicle v = new Car();
        v.start();
        v.stop();
    }
}