Encapsulation

The Essence of Encapsulation:

Encapsulation is the wrapping up of data (fields/variables) and methods operating on that data into a single, cohesive computational unit (the Class). It acts as a protective shield that prevents the data from being arbitrarily accessed and modified by external code outside the shield.

The Imperative of Data Hiding:

Without encapsulation, public fields can be corrupted at any time by rogue or careless client code:

// Dangerous unencapsulated code:
class BankAccount {
    public double balance; // Public vulnerability!
}
// Client code can execute:
BankAccount acc = new BankAccount();
acc.balance = -50000.0; // Corrupts business integrity!

By declaring balance as private and channeling all updates through a public deposit() or withdraw() method, the class enforces strict validation rules (e.g., rejecting negative amounts and overdrafts).

The Four Access Levels in Java:

Controlled Read/Write Protocols:

A well-encapsulated class exposes its private state via standardized accessor (getter) and mutator (setter) methods following JavaBeans naming conventions:

• Getter Method: A pure public method returning the private field's value (e.g., public int getAge() { return age; }).
• Setter Method: An impure public method receiving a new value, validating it, and updating the private field (e.g., public void setAge(int age) { if (age > 0) this.age = age; }).
• Read-Only Classes: Omit all setter methods to create immutable objects whose state cannot be mutated after constructor initialization.
• Write-Only Classes: Omit getter methods (e.g., for secure password entry).

Abstraction vs Encapsulation:

Creating and Utilizing User-Defined Packages:

A package is both a naming mechanism and a physical directory structure. To place a class into a package, the package statement must be the VERY FIRST non-comment line in the source file:

package com.targetexams.school; // Line 1: Must be first statement!

public class ReportCard {
    // Class implementation
}

Importing Packages:

External classes access packaged classes using the import keyword:

• import java.util.Scanner; (Specific class import - optimal performance and zero naming ambiguity).
• import java.util.*; (Wildcard import - imports all classes in the package, but NOT sub-packages).

Three Core Engineering Benefits:

1. Modularity & Maintainability: The source code of an encapsulated class can be completely rewritten (e.g., switching from an array to a database backend) without breaking external calling code, provided public method signatures remain unchanged.
2. Security & Robustness: Internal state cannot be placed into invalid or corrupt states through unauthorized external modification.
3. Loose Coupling & High Cohesion: Classes remain independent components with well-defined public communication contracts.

Model Program 1: Fully Encapsulated Bank Account with Data Validation

public class BankAccount {
    // 1. Private Data Members (Data Hiding)
    private String accountNumber;
    private String accountHolder;
    private double balance;

    // 2. Parameterized Constructor
    public BankAccount(String accNo, String holder, double initialDeposit) {
        this.accountNumber = accNo;
        this.accountHolder = holder;
        if (initialDeposit >= 500.0) {
            this.balance = initialDeposit;
        } else {
            System.out.println("Warning: Minimum opening deposit is Rs. 500. Balance set to 500.0.");
            this.balance = 500.0;
        }
    }

    // 3. Getter Methods (Accessors)
    public String getAccountNumber() { return accountNumber; }
    public String getAccountHolder() { return accountHolder; }
    public double getBalance() { return balance; }

    // 4. Mutator Methods with Strict Encapsulated Business Rules
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Rs. " + amount + " deposited successfully. Updated Balance: Rs. " + balance);
        } else {
            System.out.println("Error: Deposit amount must be strictly positive!");
        }
    }

    public void withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Error: Withdrawal amount must be positive!");
        } else if (balance - amount < 500.0) {
            System.out.println("Error: Insufficient funds! Minimum balance of Rs. 500 must be retained.");
        } else {
            balance -= amount;
            System.out.println("Rs. " + amount + " withdrawn successfully. Remaining Balance: Rs. " + balance);
        }
    }

    public static void main(String[] args) {
        BankAccount acc = new BankAccount("SB-10294", "Pooja Hegde", 15000.0);
        acc.deposit(5000.0);
        acc.withdraw(18000.0); // Rejected due to minimum balance rule!
        acc.withdraw(8000.0);  // Accepted
    }
}

Model Program 2: Encapsulated Employee Class with Salary Computation

public class EmployeeSalary {
    private int pan;
    private String name;
    private double taxIncome;
    private double tax;

    public void inputInfo(int pan, String name, double taxIncome) {
        this.pan = pan;
        this.name = name;
        this.taxIncome = taxIncome;
    }

    public void calTax() {
        if (taxIncome <= 250000) {
            tax = 0.0;
        } else if (taxIncome <= 500000) {
            tax = (taxIncome - 250000) * 0.10;
        } else if (taxIncome <= 1000000) {
            tax = (250000 * 0.10) + ((taxIncome - 500000) * 0.20);
        } else {
            tax = (250000 * 0.10) + (500000 * 0.20) + ((taxIncome - 1000000) * 0.30);
        }
    }

    public void displayInfo() {
        System.out.println("Pan Number	Name		Taxable Income	Tax Payable");
        System.out.println(pan + "		" + name + "		Rs. " + taxIncome + "	Rs. " + tax);
    }

    public static void main(String[] args) {
        EmployeeSalary emp = new EmployeeSalary();
        emp.inputInfo(1092837, "Rajesh Kumar", 750000.0);
        emp.calTax();
        emp.displayInfo();
    }
}