🚀 Day 14 of My Automation Journey – Encapsulation & Access Modifiers in Java

Today I learned one of the most important Object-Oriented Programming (OOP) concepts in Java — Encapsulation.

Encapsulation is used to protect data and control access to variables and methods inside a class.

📦 What is Encapsulation?

The word Encapsulation comes from the concept of a Capsule.

A capsule keeps medicines safely enclosed inside it.

Similarly in Java:

Encapsulation means wrapping data (variables) and code (methods) together in a single unit (class) and restricting direct access to some components.

📌 In simple words:

Encapsulation = Data Protection

🎯 Why Do We Use Encapsulation?

Encapsulation provides several advantages:

✔ Protects sensitive data
✔ Prevents unauthorized access
✔ Improves code maintainability
✔ Makes code more secure
✔ Allows controlled access using methods

🔑 How Do We Protect Data in Java?

Java uses Access Modifiers to control access.

These modifiers define who can access variables, methods, and classes.

🔐 Types of Access Modifiers in Java

Java provides four types of access modifiers:

| Access Modifier | Same Class | Same Package | Subclass | Different Package |
| --------------- | ---------- | ------------ | -------- | ----------------- |
|   private       |    ✅      |     ❌      |    ❌    |       ❌         |
|   default       |    ✅      |     ✅      |    ❌    |       ❌         |
|   protected     |    ✅      |     ✅      |    ✅    |       ❌*        |
|   public        |    ✅      |     ✅      |    ✅    |       ✅         |

(*Protected works in another package only through inheritance)

💻 Example Used in My Code

I created a class called Bala with variables using different access modifiers.

package developer;

public class Bala {

    private int salary = 10000;
    String work = "Development";
    protected String headphone = "sony";
    public String Designation = "Developer";

    public static void main(String[] args) {
        Bala bala1 = new Bala();
        System.out.println(bala1.salary);
    }
}

| Variable    | Access Modifier | Access Level               |
| ----------- | --------------- | -------------------------- |
| salary      | private         | Only inside the same class |
| work        | default         | Same package only          |
| headphone   | protected       | Same package + subclass    |
| Designation | public          | Anywhere                   |

Example:

package developer;

public class Nantha extends Bala {

    public static void main(String[] args) {

        Nantha NanthaKumar = new Nantha();

        System.out.println(NanthaKumar.work);
        System.out.println(NanthaKumar.headphone);
        System.out.println(NanthaKumar.Designation);

    }
}

Accessible

✔ default variable (work)
✔ protected variable (headphone)
✔ public variable (Designation)

Not Accessible

❌ private variable (salary)

🌍 Access From Different Package

Example:

package tester;

import developer.Bala;

public class Deepika extends Bala {

    public static void main(String[] args) {

        Deepika deepika = new Deepika();

        System.out.println(deepika.headphone);
        System.out.println(deepika.Designation);

    }
}

Accessible

✔ protected (through inheritance)
✔ public

Not Accessible

❌ private
❌ default

🧑‍💻 Access Using Object in Another Package

package tester;

import developer.Bala;

public class Kumar extends Bala {

    public static void main(String[] args) {

        Kumar kumar = new Kumar();
        System.out.println(kumar.Designation);

        Bala bala = new Bala();
        System.out.println(bala.Designation);

    }
}

Here:

✔ public variable is accessible everywhere.

⚠️ Exceptional Scenarios in Encapsulation

These are important situations where access modifiers behave differently.

1️⃣ Private Variable Access

Private variables cannot be accessed outside the class.

Example (Error):

NanthaKumar.salary

✔ Solution: Use Getter and Setter methods.

In Java, private variables cannot be accessed directly outside the class. They are accessed using public getter and setter methods. This concept is part of encapsulation.

Example

class Student {

    private int age;   // private variable

    // Getter method
    public int getAge() {
        return age;
    }

    // Setter method
    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {

        Student s = new Student();

        s.setAge(20);              // setting value
        System.out.println(s.getAge());   // accessing value
    }
}

Explanation

• private int age; → Cannot be accessed directly outside the class.
• setAge() → Used to assign value to the private variable.
• getAge() → Used to retrieve the value.

Output

20

2️⃣ Default Modifier Limitation

Default variables cannot be accessed outside the package.

Example:

System.out.println(deepika.work);

❌ Compilation error.

3️⃣ Protected Access in Different Package

Protected variables are accessible only through inheritance.

Example:

Deepika extends Bala

✔ Accessible.

But:

Bala b = new Bala();
b.headphone

❌ Not accessible.

4️⃣ Public Access

Public members can be accessed from anywhere in the program.

Example:

System.out.println(bala.Designation);

✔ Works everywhere.

5️⃣ Private Access Through Getter & Setter

In real-world projects, private variables are accessed through getter and setter methods.

Example:

private int salary;

public int getSalary(){
    return salary;
}

This is the real implementation of encapsulation.

🧠 Key Takeaways

✔ Encapsulation protects data
✔ Access modifiers control visibility
✔ Private variables improve security
✔ Getter & Setter methods provide controlled access
✔ Encapsulation is widely used in automation frameworks

🤖 A Small Note
I used ChatGPT to help structure and refine this blog while ensuring the concepts remain aligned with my trainer’s explanations.