Join Our 4-Week Free Gen AI Course with select Programs.

Request a callback

or Chat with us on

Learning Hub

Articles

Encapsulation in Java: Secure, Clean, and Flexible Code

Basics of Python

5 Hrs. duration

9 Modules

1800+ Learners

Start Learning

If you have ever worked on a Java project, you must have worried about keeping your code clean and safe. Perhaps you asked yourself, “How do I prevent other parts of my program from accessing and messing with sensitive data?” Or, “How do I make my code maintainable and modifiable without making a mess?”

That’s where encapsulation in Java takes its place. You put your valuables into the safe box, and you know they are just fine; only the right people with a key could open it.

Encapsulation is one of the most important concepts of Object-Oriented Programming. This enables us to put together our data, usually variables, and methods, typically functions operating on that data, into one unit.

Encapsulation hides what doesn’t need to be seen and controls how data is accessed. By doing this, we prevent unwanted interference from outside code.

This keeps us safe from bugs, making the code easier to handle over time.

Let’s take a look at how all this works and why it is such a powerful feature for Java developers.

encapsulation

The Core Mechanism of Encapsulation and How It Works in Java

Essentially, encapsulation in Java means wrapping up data, which is variables, together with methods that function into one unit, usually a class. Consequently, we have the ability to exercise control over who gains access to the data and how such persons will interact with the data.

Here is how it works: we declare the variables inside a class private. This means that we will not be allowed to have direct access to those variables from outside the class. Instead, we provide public methods, known as getters and setters, for accessing and modifying the data.

Why don’t we give everybody direct access to the data?

Well, direct access increases the chances of accidental changes and errors. Therefore, by restricting access, we ensure that data remains in the shape we want it to be.

Here’s a simple analogy: Consider a vending machine. You can press the buttons to choose a certain drink, but you don’t have access to the internal mechanisms.

And exactly the same way, encapsulation works in Java-you show only what needs to be shown and hide the rest.

Example:

public class Main {  // This is your file's main class

public static void main(String[] args) {

BankAccount account = new BankAccount();

 

// Set balance and display it

account.setBalance(100.50);

account.showBalance();

 

// Try setting a negative balance

account.setBalance(-50);

}

}

 

class BankAccount {  // Encapsulated class

private double balance;  // Private field

 

// Public getter method to access balance

public double getBalance() {

return balance;

}

 

// Public setter method to update balance with validation

public void setBalance(double amount) {

if (amount > 0) {

this.balance = amount;

} else {

System.out.println("Invalid amount. Please enter a positive value.");

}

}

 

// Public method to display current balance

public void showBalance() {

System.out.println("Current balance: $" + balance);

}

}

Output:

Current balance: $100.5

Invalid amount. Please enter a positive value.

Here, we can only modify the balance through the setBalance() method. If we try to set a negative value, it’s rejected. This control prevents errors and keeps our data safe.

Also Visit: Java Tutorial For Beginners

Understanding Access Modifiers and Their Role in Java Encapsulation

Access modifiers are the backbone of encapsulation. They control who can access the variables and methods in a class.

Access Modifiers and Their Role in Java Encapsulation

Java gives us four key modifiers: private, public, protected, and the default (no modifier).

Private	Public	Protected	Default
Only accessible within the same class. This is the most restrictive and commonly used for encapsulation.	Accessible from anywhere in the program. Use this for methods that you want to be available to other classes.	Accessible within the same package or by subclasses. It’s more open than private but still offers some restrictions.	If no modifier is used, the member is accessible only within the same package.

The private access modifier has a major role in encapsulation. It is achieved by declaring class variables as private, and interference from outside can be prevented. The public getter and setter methods will guard the data and give controlled access.

Example Table of Access Modifiers:

By using access modifiers wisely, we can balance security and accessibility in our code. The goal is to expose only what’s necessary and keep everything else hidden.

Modifier	Same Class	Same Package	Subclass	Outside Package
Private	Yes	No	No	No
Public	Yes	Yes	Yes	Yes
Protected	Yes	Yes	Yes	No
Default	Yes	Yes	No	No

The Importance of Getter and Setter Methods in Controlling Data Access

In encapsulation, the key to controlling data access lies in getter and setter methods.

These methods act like controlled gateways. Instead of letting everyone access our data directly, we decide how and when the data can be accessed or changed.

Getter methods are used to retrieve or “get” the value of a private variable.
Setter methods allow us to update or “set” the value, often with some validation.

Why is this important?

Suppose we allowed direct access to our variables. Anyone could assign any value to them — even values that don’t make sense, like negative balances in a bank account. Getters and setters prevent this by allowing us to introduce rules.

class Student {  // No public keyword here

private String name;

private int age;

 

// Getter for name

public String getName() {

return name;

}

 

// Setter for name with validation

public void setName(String name) {

if (name != null && !name.isEmpty()) {

this.name = name;

} else {

System.out.println("Invalid name");

}

}

 

// Getter for age

public int getAge() {

return age;

}

 

// Setter for age with validation

public void setAge(int age) {

if (age > 0) {

this.age = age;

} else {

System.out.println("Invalid age");

}

}

 

// Method to display student details

public void displayStudentInfo() {

System.out.println("Student Name: " + name + ", Age: " + age);

}

}

 

public class Main {  // Public Main class

public static void main(String[] args) {

Student student = new Student();

 

// Set valid values

student.setName("Anurag Kashyap");

student.setAge(20);

student.displayStudentInfo();

 

// Set invalid values

student.setName("");

student.setAge(-1);

}

}

Output:

Student Name: John Doe, Age: 20

Invalid name

Invalid age

Here, the getter and setter methods ensure that only valid data is accepted. The setters reject empty names or negative ages, keeping the data consistent.

Key Benefits of Using Encapsulation in Java for Clean, Flexible, and Secure Code

When you’re building a Java project, keeping everything organised can feel overwhelming.

How do we stop bugs from creeping in? How do we ensure that our code remains easy to change?

This is where encapsulation in Java shines. It offers several key benefits that help us maintain clean, flexible, and secure code. Encapsulation in Java is our way of creating reliable, safe, and manageable code that’s built to last.

Let’s break it down:

Better security: When we use encapsulation, we hide sensitive data. Only the methods in the class can access it. This stops external code from tampering with variables.

Imagine you’re working with a bank account class. You wouldn’t want any random part of the program to change the balance directly, right? With encapsulation, we ensure only the right methods can update it.

Improved maintainability: Encapsulation makes your code flexible. If you need to update how a variable is managed, you can do it in one place — inside the class. You won’t need to touch all the other parts of your program. This makes maintenance a breeze.

Increases reusability: The immediate benefit of encapsulation is that once your class is encapsulated, it can be reused throughout your project, even in any future projects you may work on, without needing to make adjustments.

Easier to test: Encapsulated code is simple to test. When you bundle the data with methods inside the class, you create a clear structure. You can focus on testing how the methods work with the data without worrying about what’s going on elsewhere.

Reduces code complexity: We’ve all seen those tangled webs of code where everything seems connected. Encapsulation breaks that cycle. It keeps everything neat, separating what needs to be separate. Your code will become easier to understand and work with.

Explanation of How to Implement Encapsulation in Java Step by Step

Step 1: Creating the Class and Declaring the Variables as Private

The variables should be declared as private within the class. Consequently, it is impossible for the program to directly access the variables in any part.

class Employee {

private String employeeName;

private int employeeID;

}

Step 2: Use Getter and Setter Methods to Access and Modify Variables

Next, we need to create getter and setter methods. These will allow other classes to access or change the variables, but only through these controlled methods.

This is where we can apply validation or logic to ensure data consistency.

// Getter method for employeeName

public String getEmployeeName() {

return employeeName;

}

 

// Setter method for employeeName

public void setEmployeeName(String name) {

if (!name.isEmpty()) {

this.employeeName = name;

} else {

System.out.println("Name cannot be empty");

}

}

 

// Getter method for employeeID

public int getEmployeeID() {

return employeeID;

}

 

// Setter method for employeeID with validation

public void setEmployeeID(int id) {

if (id > 0) {

this.employeeID = id;

} else {

System.out.println("ID must be a positive number");

}

}

Step 3: Test the Encapsulated Class

Let’s see how this works in action. We’ll create an instance of the Employee class, set the values, and print them out.

public class Main {

public static void main(String[] args) {

Employee emp = new Employee();

 

// Setting values

emp.setEmployeeName("Amit");

emp.setEmployeeID(101);

 

// Getting and printing values

System.out.println("Employee Name: " + emp.getEmployeeName());

System.out.println("Employee ID: " + emp.getEmployeeID());

 

// Trying invalid data

emp.setEmployeeName("");

emp.setEmployeeID(-5);

}

}

Output:

Employee Name: Amit

Employee ID: 101

Name cannot be empty

ID must be a positive number

Internship Assurance

DevOps & Cloud Engineering

Explore

Understanding the Concept of Data Hiding vs. Encapsulation in Java

The concepts of data hiding and encapsulation seem synonyms, but they don’t mean the same thing.

	Conceptual Difference	Vending Machine Analogy
Encapsulation	This is the broader concept of bundling data and methods together. It ensures that we control how data is accessed and modified.	Encapsulation is the entire vending machine. It wraps everything — the buttons, the mechanism, and the drink inside.
Data Hiding	This is one aspect of encapsulation. It refers specifically to making the internal details of a class invisible to the outside world. Data hiding is achieved through the use of private access modifiers. This hides the variables from other classes, so they can’t access them directly.	Data hiding is like making the machine’s internal workings hidden from view. We don’t need to know how the machine works to get a drink. We just press the button.

How Encapsulation in Java Can Be Used to Make a Class Read-Only or Write-Only

Sometimes, we may want to restrict access to our class in a more particular fashion. This is where the read-only and write-only classes come in.

Creating a Read-Only Class

A read-only class is one where we can only retrieve data, but we can’t change it. We achieve this by providing getter methods but no setter methods.

class ReadOnlyAccount {  // No 'public' keyword here

private double balance;

 

// Constructor to set the balance

public ReadOnlyAccount(double initialBalance) {

this.balance = initialBalance;

}

 

// Getter method to access the balance

public double getBalance() {

return balance;

}

}

 

public class Main {

public static void main(String[] args) {

ReadOnlyAccount account = new ReadOnlyAccount(500.00);

 

// Accessing the balance

System.out.println("Account Balance: $" + account.getBalance());

 

// Trying to modify the balance (not possible)

// account.setBalance(1000.00);  // No setter method available

}

}

Output:

Account Balance: $500.0

Creating a Write-Only Class

A write-only class is one where we can change the data but never retrieve it. We do this by including setter methods without getter methods.

class WriteOnlyUser {  // No 'public' keyword here

private String password;

 

// Setter method to set the password

public void setPassword(String password) {

if (password.length() >= 6) {

this.password = password;

} else {

System.out.println("Password must be at least 6 characters long");

}

}

}

 

public class Main {

public static void main(String[] args) {

WriteOnlyUser user = new WriteOnlyUser();

 

// Setting the password

user.setPassword("mySecretPassword");

 

// Trying to retrieve the password (not possible)

// System.out.println(user.getPassword());  // No getter method available

}

}

Common Mistakes Developers Make When Implementing Encapsulation and How to Avoid Them

Not using private access modifiers for variables

Always make your variables private so other classes can’t access them directly.

Overuse of getter and setter methods

If a variable doesn’t need to be modified outside the class, don’t provide a setter method.

Skipping validation in setters

Setters give us a chance to validate data before it’s stored. Forgetting this is a missed opportunity.

Allowing too many public methods

If a class has too many public methods, it might expose too much functionality.

Conclusion

Encapsulation in Java creates a structure where data is protected and code is more maintainable and flexible. It controls access to class variables, allowing only the right methods to modify or retrieve data, which increases security.

By using getter and setter methods, encapsulation provides control over data manipulation, ensuring consistency. This principle also enhances flexibility by allowing internal changes without affecting the rest of the system, making it easier to maintain and adapt code over time.

Whether it’s securing sensitive information or simplifying future updates, encapsulation plays a critical role in writing clean, reliable, and adaptable Java code.

FAQs

Can you implement encapsulation without getter and setter methods?

Technically, yes, but not recommended. The reason is that getters and setters provide controlled access to private variables and ensure any validation or logic is applied as long as the data is being accessed or changed. Without it, we cannot guarantee that the data is being manipulated accordingly.

What are the main advantages of using encapsulation in Java?

Major advantages are improved security, better code organisation, ease of maintenance, and increased flexibility. That means developers can change how something is implemented in a class, without any other part of the program necessarily knowing about such change.

Can encapsulation cause over-complication?

If used incorrectly, yes. Too much use of methods like get and set or sometimes making too many methods public leads to complications in your code. The key is to only expose what’s necessary and keep your variables private.

Deploying Applications Over the Cloud Using Jenkins

Prashant Kumar Dey

Associate Program Director - Hero Vired

Ex BMW | Google

24 October, 7:00 PM (IST)

Limited Seats Left

Book a Free Live Class

Programs tailored for your success

Popular

Management

Data Science

Finance

Technology

Future Tech

3 ASSURED INTERVIEWS

Accelerator Program in

Business Analytics and Data Science

With

Part-time · 10 months

Apply by : 26 October, 2024

Financial Analysis, Valuation, & Risk Management

3 ASSURED INTERVIEWS

Certificate Program in

Financial Analysis, Valuation, & Risk Management

With

Part-time · 7 months

Apply by : 26 October, 2024

INTERNSHIP ASSURANCE

Certificate Program in

DevOps & Cloud Engineering

With

Part-time · 7.5 months

Apply by : 26 October, 2024

Upskill with expert articles

View all

Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.

Data Science

Accelerator Program in Business Analytics & Data Science

Integrated Program in Data Science, AI and ML

Accelerator Program in AI and Machine Learning

Advanced Certification Program in Data Science & Analytics

Technology

Certificate Program in Full Stack Development with Specialization for Web and Mobile

Certificate Program in DevOps and Cloud Engineering

Certificate Program in Application Development

Certificate Program in Cybersecurity Essentials & Risk Assessment

Finance

Integrated Program in Finance and Financial Technologies