Java Encapsulation - Data Hiding and Controlled Access

⏱️ 22 min read • Beginner Level • Lesson 55

Encapsulation in Java combines data and behavior inside a class while protecting internal state from uncontrolled outside access.

A well-encapsulated class exposes a small, meaningful API and keeps implementation details restricted. This allows the class to validate data, protect its rules, and change its internal representation without forcing every caller to change.

What is Encapsulation in Java?

Encapsulation is an object-oriented programming principle in which a class keeps related state and behavior together and controls how outside code interacts with that state.

Real-World Analogy

A bank account is a useful analogy. Customers cannot directly edit the balance stored in the bank's system. Instead, they use controlled operations such as deposit, withdraw, and check balance.

Why Use Encapsulation?

How Encapsulation Works

Basic Encapsulation Example

class Student {
    private String name;
    private int marks;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setMarks(int marks) {
        if (marks >= 0 && marks <= 100) {
            this.marks = marks;
        }
    }

    public int getMarks() {
        return marks;
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("Ayan");
        student.setMarks(88);

        System.out.println(student.getName());
        System.out.println(student.getMarks());
    }
}

Output:

Ayan
88

Encapsulation with Validation

Silently ignoring invalid data can hide programming mistakes. A stronger design often reports invalid input immediately.

class BankAccount {
    private double balance;

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

    public void withdraw(double amount) {
        if (amount <= 0 || amount > balance) {
            throw new IllegalArgumentException(
                    "Invalid withdrawal amount");
        }
        balance -= amount;
    }

    public double getBalance() {
        return balance;
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(2000);
        account.withdraw(500);

        System.out.println(account.getBalance());
    }
}

Output:

1500.0

Getters and Setters

Getters and setters are common tools, but they are not the definition of encapsulation. A method should be added only when that operation belongs in the class's public or internal API.

Read-only and Write-only Designs

class Product {
    private final String code;

    Product(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

class PasswordVault {
    private String passwordHash;

    public void setPassword(String value) {
        passwordHash = hash(value);
    }

    private String hash(String value) {
        return Integer.toHexString(
                value.hashCode());
    }
}

Prefer Domain-specific Methods

A domain-specific method communicates purpose and keeps related validation together. For example, changePassword(), enroll(), and deposit() are often better than generic setters.

Encapsulation and Defensive Copying

A private field is not fully protected if a getter returns the same mutable object reference. Outside code could modify the internal object without going through class rules.

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

class Course {
    private final List<String> students = new ArrayList<>();

    public void enroll(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name is required");
        }
        students.add(name);
    }

    public List<String> getStudents() {
        return List.copyOf(students);
    }

    public static void main(String[] args) {
        Course course = new Course();
        course.enroll("Ayan");
        course.enroll("Sarah");

        System.out.println(course.getStudents());
    }
}

Output:

[Ayan, Sarah]

Encapsulation vs Immutability

Encapsulation vs Abstraction

Benefits of Encapsulation

Encapsulation Best Practices

Tricky Cases

1. Does private automatically mean fully encapsulated?

2. Does every private field need a getter and setter?

3. Can an encapsulated object be mutable?

4. Is a public setter always safe?

5. Does final make a referenced object immutable?

6. Can a getter expose a calculated value?

Common Mistakes

Interview Questions ⭐

Test your understanding with a quick quiz

class BankAccount {
    private double balance;

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

    public double getBalance() {
        return balance;
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(-100);
        account.deposit(500);
        System.out.println(account.getBalance());
    }
}

class Student {
    private int marks = 90;
}

class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.marks);
    }
}

Great job! Continue learning Java OOP step by step.