Encapsulation in Java – Data Hiding with Examples

public class WithoutEncapsulation {
    static class Account {
        public String owner;
        public double balance;     // anyone can write anything
    }

    public static void main(String[] args) {
        Account acc = new Account();
        acc.owner = "";            // invalid owner
        acc.balance = -50_000;     // invalid balance, no checks possible
        System.out.println("Owner: '" + acc.owner + "', balance: " + acc.balance);
    }
}

public class EncapsulatedAccount {
    static class Account {
        private final String owner;     // hidden, and fixed after creation
        private double balance;         // hidden; changed only through methods

        Account(String owner, double opening) {
            if (owner == null || owner.isBlank()) throw new IllegalArgumentException("owner is required");
            if (opening < 0) throw new IllegalArgumentException("opening balance cannot be negative");
            this.owner = owner;
            this.balance = opening;
        }

        public String getOwner()   { return owner; }      // read-only property
        public double getBalance() { return balance; }

        public void deposit(double amount) {
            if (amount <= 0) throw new IllegalArgumentException("deposit must be positive");
            balance += amount;
        }

        public void withdraw(double amount) {
            if (amount <= 0) throw new IllegalArgumentException("withdrawal must be positive");
            if (amount > balance) throw new IllegalStateException("insufficient funds");
            balance -= amount;
        }
    }

    public static void main(String[] args) {
        Account acc = new Account("Asha", 1_000);
        acc.deposit(500);
        acc.withdraw(300);
        System.out.println(acc.getOwner() + " has " + acc.getBalance());

        try { acc.withdraw(5_000); }
        catch (IllegalStateException e) { System.out.println("Rejected: " + e.getMessage()); }
        try { acc.deposit(-10); }
        catch (IllegalArgumentException e) { System.out.println("Rejected: " + e.getMessage()); }
        // acc.balance = 1_000_000;   // compile error: balance has private access
        System.out.println("Balance still " + acc.getBalance());
    }
}

public class ChangeInternals {
    // Version 2 stores the temperature in Kelvin internally.
    // The public API (Celsius getters/setters) did not change, so no caller breaks.
    static class Thermostat {
        private double kelvin = 293.15;

        public double getCelsius() { return kelvin - 273.15; }
        public void setCelsius(double celsius) {
            if (celsius < -273.15) throw new IllegalArgumentException("below absolute zero");
            kelvin = celsius + 273.15;
        }
        public double getFahrenheit() { return getCelsius() * 9 / 5 + 32; }   // new feature, free
    }

    public static void main(String[] args) {
        Thermostat t = new Thermostat();
        t.setCelsius(25);
        System.out.printf("%.1f C = %.1f F%n", t.getCelsius(), t.getFahrenheit());
    }
}

import java.util.ArrayList;
import java.util.List;

public class DefensiveCopy {
    static class Team {
        private final List<String> members;

        Team(List<String> members) {
            this.members = new ArrayList<>(members);       // copy in
        }
        public List<String> getMembers() {
            return List.copyOf(members);                    // read-only copy out
        }
        public void addMember(String name) {
            if (members.size() >= 3) throw new IllegalStateException("team is full");
            members.add(name);
        }
    }

    static class LeakyTeam {
        private final List<String> members = new ArrayList<>();
        public List<String> getMembers() { return members; } // leaks internal list!
    }

    public static void main(String[] args) {
        LeakyTeam leaky = new LeakyTeam();
        leaky.getMembers().add("Intruder");                  // bypasses any rules
        System.out.println("Leaky team: " + leaky.getMembers());

        List<String> input = new ArrayList<>(List.of("Asha", "Ravi"));
        Team team = new Team(input);
        input.add("Sneaky");                                 // does not affect team
        team.addMember("Meera");
        System.out.println("Team: " + team.getMembers());
        try {
            team.getMembers().add("Intruder");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify the returned list: " + e.getClass().getSimpleName());
        }
    }
}

public class RecordEncapsulation {
    // Records: private final fields, accessors, equals/hashCode/toString generated
    record Email(String value) {
        Email {                                   // compact constructor validates input
            if (value == null || !value.matches("[^@\\s]+@[^@\\s]+\\.[a-z]{2,}"))
                throw new IllegalArgumentException("invalid email: " + value);
            value = value.toLowerCase();
        }
    }

    public static void main(String[] args) {
        Email e = new Email("Asha@JavaByTechie.com");
        System.out.println(e.value());
        System.out.println(e);
        try { new Email("not-an-email"); }
        catch (IllegalArgumentException ex) { System.out.println(ex.getMessage()); }
    }
}