Learn how encapsulation in Java secures data by hiding object state, using getter-setter methods and real-world examples like bank systems.
Introduction: What Is Encapsulation?
In Java Object Oriented Programming, Encapsulation is one of the core pillars, alongside inheritance, polymorphism, and abstraction. It involves wrapping data (variables) and methods (functions) together into a single unit called a class and restricting direct access to the internal state of that class.
Through Encapsulation in Java, you hide the internal representation of an object from the outside. Only specific, controlled interfaces (via getters and setters) are exposed for interaction.
This promotes:
Data security
Code modularity
Flexibility in changing code without affecting external classes
Cleaner, more readable structure
Why Is Encapsulation So Important?
Here’s why encapsulation in Java is not just a technical mechanism but a best practice for secure and maintainable code:
Controlled Access: Private variables and public methods enforce boundaries.
Improved Security: Only specific functions can manipulate data, preventing accidental damage or misuse.
Easier Maintenance: Internal implementation can change without affecting external code.
Data Integrity: Prevents unintended access or modifications.
These advantages make encapsulation essential in real-world development from banking systems to enterprise-grade applications.
Encapsulation in Action: Banking System Example
Let’s walk through a real time example of encapsulation in Java by creating a simple banking system.
Use Case:
A BankAccount class will hold:
Account Number
Account Holder Name
Account Type
Account Balance
These attributes will be encapsulated, and access will be controlled through getter and setter methods.
Java Encapsulation Example Program:
public class BankAccount { private long accountNumber; private String accountHolderName; private String accountType; private double balance; public BankAccount(long accountNumber, String accountHolderName, String accountType, double balance) { this.accountNumber = accountNumber; this.accountHolderName = accountHolderName; this.accountType = accountType; this.balance = balance; } public long getAccountNumber() { return accountNumber; } public String getAccountHolderName() { return accountHolderName; } public String getAccountType() { return accountType; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } @Override public String toString() { return this.getAccountNumber() + “, “ + this.getAccountHolderName() + “, “ + this.getAccountType() + “, “ + this.getBalance(); } }
Main Class to Test:
public class Main { public static void main(String[] args) { BankAccount account = new BankAccount(1234567890, “Komali”, “Saving”, 12780); System.out.println(account); account.setBalance(account.getBalance() + 1000.0); double balance = account.getBalance(); System.out.println(“New Balance: $” + balance); // This would give an error: // System.out.println(account.balance); // Not allowed (private access) } }
Output:
1234567890, Komali, Saving, 12780.0 New Balance: $13780.0
This Java code for bank account demonstrates encapsulation by restricting direct access to internal fields, providing only controlled ways to modify or retrieve data.
Breaking Down the Components
1. Private Fields — Why?
Declaring fields as private hides them from outside classes. This is a key part of How to secure data in Java.
2. Public Getters/Setters
These methods offer controlled access to fields. You can add validation logic in setters, further securing data.
3. No Setter for Account Number
In real-world systems, some fields should remain immutable once initialized. This improves data integrity.
Please visit our website to know more:-https://cyberinfomines.com/blog-details/encapsulation-in-java
