Encapsulation: Data Protection

Duration: 5 min

What is Encapsulation?

Encapsulation is the bundling of data (attributes) and methods that operate on that data into a single unit (class). It also involves hiding the internal details of how an object works and exposing only what is necessary through a public interface.

Encapsulation is achieved using access modifiers (private, public, protected) and getter/setter methods.

Benefits of Encapsulation

• Data Protection: Prevent unauthorized access and modification
• Validation: Control how data is set through setter methods
• Flexibility: Change internal implementation without affecting external code
• Maintainability: Easier to modify and debug code
• Security: Hide sensitive information

public class BankAccount {
    private String accountNumber;
    private double balance;
    private String accountHolder;
    
    public BankAccount(String accountNumber, String accountHolder, double initialBalance) {
        this.accountNumber = accountNumber;
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }
    
    // Getter for balance
    public double getBalance() {
        return balance;
    }
    
    // Deposit method with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: " + amount + ". New balance: " + balance);
        } else {
            System.out.println("Invalid deposit amount");
        }
    }
    
    // Withdraw method with validation
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: " + amount + ". New balance: " + balance);
        } else {
            System.out.println("Invalid withdrawal amount");
        }
    }
    
    public void displayInfo() {
        System.out.println("Account: " + accountNumber + ", Holder: " + accountHolder + ", Balance: " + balance);
    }
}

No output - this is a class definition

public class BankDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("ACC123", "John Doe", 1000);
        
        account.displayInfo();
        account.deposit(500);
        account.withdraw(200);
        account.withdraw(2000);  // Invalid - insufficient balance
        account.deposit(-100);   // Invalid - negative amount
    }
}

Account: ACC123, Holder: John Doe, Balance: 1000.0
Deposited: 500.0. New balance: 1500.0
Withdrawn: 200.0. New balance: 1300.0
Invalid withdrawal amount
Invalid deposit amount

Encapsulation Best Practices

• Make attributes private
• Provide public getter and setter methods
• Add validation in setter methods
• Don't expose internal implementation details
• Use meaningful method names
• Document your public interface

💡 Tip: Encapsulation is not just about hiding data - it's about controlling how data is accessed and modified to maintain object integrity.

Learn more: https://docs.oracle.com/javase/tutorial/java/javaOO/index.html

// Advanced example for Encapsulation: Data Protection
// Production-ready pattern
System.out.println("Advanced implementation");

Advanced implementation

💡 Tip: Pro Tip: Master Encapsulation thoroughly. This foundation is crucial for writing professional Java code.