Encapsulation in Java

Encapsulation bundles data (fields) and the methods that operate on it inside a single class while hiding internal state. By marking fields private and exposing controlled getters and setters, you protect data integrity, enable validation and decouple internals from external code.

• Declare fields private.
• Expose public getter: getName().
• Expose public setter: setName(String name).
• Validate inside setters before assignment.

Let's start with a hands-on example. The program below shows the core idea behind Encapsulation in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Student
{
    private String name;
    private int    age;

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

    public int    getAge()            { return age; }
    public void   setAge(int a)
    {
        if (a > 0) this.age = a;
    }
}

class Main
{
    public static void main(String args[])
    {
        Student s = new Student();
        s.setName("Aman");
        s.setAge(22);

        System.out.println(s.getName() + " " + s.getAge());
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class Account
{
    private double balance;

    public double getBalance() { return balance; }

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

class Main
{
    public static void main(String args[])
    {
        Account a = new Account();
        a.deposit(500);
        a.deposit(-100);   // rejected

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

class Product
{
    private final String code;
    private double       price;

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

    public String getCode()  { return code; }
    public double getPrice() { return price; }

    public void setPrice(double p) { if (p > 0) price = p; }
}

class Main
{
    public static void main(String args[])
    {
        Product p = new Product("SKU-101");
        p.setPrice(199);
        System.out.println(p.getCode() + " - " + p.getPrice());
    }
}

class Circle
{
    private double radius;

    public Circle(double r) { radius = r; }

    public double getArea() { return 3.14 * radius * radius; }
}

class Main
{
    public static void main(String args[])
    {
        System.out.println(new Circle(5).getArea());
    }
}

class Person
{
    private String name;
    private int    age;

    public Person(String n, int a)
    {
        setName(n);
        setAge(a);
    }

    public String getName() { return name; }
    public int    getAge()  { return age;  }

    public void setName(String n) { if (n != null && !n.isEmpty()) name = n; }
    public void setAge(int a)     { if (a >= 0 && a < 120)         age = a; }
}

class Main
{
    public static void main(String args[])
    {
        Person p = new Person("Riya", 25);
        System.out.println(p.getName() + " " + p.getAge());
    }
}

• Always make fields private unless you have a strong reason.
• Provide getters and setters only when truly needed.
• Setters are the perfect place for validation.
• Encapsulation supports information hiding, a key OOP principle.
• Combine encapsulation with immutability for thread-safe data classes.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Create a Box class with private dimensions and computed volume getter.
• Q2. Build a BankAccount class with deposit, withdraw and balance encapsulated.
• Q3. Write a Person class that rejects negative ages.
• Q4. Create a Product class with a final SKU and a mutable price.
• Q5. Refactor a public-field class into a fully encapsulated one.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Encapsulation in Java:

• Forgetting the semicolon ; at the end of statements while using Encapsulation.
• Mixing up similar method names — read Java docs before using new APIs related to Encapsulation.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.