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

Request a callback

or Chat with us on

Encapsulation in Java: Secure, Clean, and Flexible Code

Basics of Python
Basics of Python
icon
5 Hrs. duration
icon
9 Modules
icon
1800+ Learners
logo
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.

 

Also Read: Mastering Loops in Java

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.

 

Also Read: Java String Methods

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
DevOps & Cloud Engineering
Internship Assurance
DevOps & Cloud Engineering

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.

 

 

Also Read: Logical Operators in Java

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
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.
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.
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.
brochureimg

The DevOps Playbook

Simplify deployment with Docker containers.

Streamline development with modern practices.

Enhance efficiency with automated workflows.

left dot patternright dot pattern

Programs tailored for your success

Popular

Management

Data Science

Finance

Technology

Future Tech

Upskill with expert articles

View all
Hero Vired logo
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

Certificate Program in Financial Analysis, Valuation and Risk Management

Management

Certificate Program in Strategic Management and Business Essentials

Executive Program in Product Management

Certificate Program in Product Management

Certificate Program in Technology-enabled Sales

Future Tech

Certificate Program in Gaming & Esports

Certificate Program in Extended Reality (VR+AR)

Professional Diploma in UX Design

Blogs
Reviews
Events
In the News
About Us
Contact us
Learning Hub
18003093939     ·     hello@herovired.com     ·    Whatsapp
Privacy policy and Terms of use

© 2024 Hero Vired. All rights reserved