What is Encapsulation in OOPS? Types, Examples, Implementation, & More

Do you know what encapsulation in OOPS is? If no, don’t worry, you are at the right place! Encapsulation in OOPS (Object-Oriented Programming) is a vital concept that protects your data and keeps your classes neat. By bundling related properties and functions into a single unit, you decide exactly how outsiders interact with that unit, preventing unwanted meddling and keeping your code simpler to maintain.

Whether you are building small projects or tackling more complex tasks, this approach helps you avoid messy code and unexpected bugs.

In this blog, you'll explore the core ideas behind encapsulation in OOPS and discover how C++, Java, and Python handle it. You'll learn about different types of encapsulation, understand its advantages and disadvantages, and pick up insights on data security and code organization. 

What is Encapsulation in OOPS, and What are its Types?

Encapsulation in Object-Oriented Programming combines data (attributes) and methods (functions) under one class. This allows you to control exactly how those methods interact with each other and how much of that interaction is visible to outside code.

Keeping certain parts private prevents unauthorized or accidental changes and maintains a clean boundary around your data.

Let’s understand it better with an example – consider a simple ‘StudentRecord’ class that manages a student’s name, marks, and roll number. In many programming languages, you control access to class members through access specifiers listed below:

• Private Variables: You keep names and marks hidden, so no one updates them directly.
• Public Methods: You create setters and getters to handle these variables. If someone tries to pass invalid marks, you can reject that upfront.
• Data Consistency: Any future updates to ‘StudentRecord’ remain inside the class, so they don’t break anything else in your program.

In simple terms, encapsulation in OOPS means wrapping data and methods into a single unit — a class — and restricting direct access to some components. Now that you understand encapsulation meaning in programming, you’ll see how it can take different forms in OOPS in the next section.

What Are the Types of Encapsulation in OOPS?

When discussing Encapsulation in OOPS, different strategies can help securely organize data and functions. 

Here are the common approaches you might find:

• Member Variable Encapsulation: This focuses on declaring variables as private (or protected). You then provide specific methods to read or change those variables, preventing unwanted direct access.
• Function Encapsulation: Specific functions are marked private, limiting who can call them. Only authorized methods within the class or its subclasses can interact with these functions.
• Class Encapsulation: An entire class can be hidden from external code. If you label the class private (or package-private, depending on the language), any outside code won’t be able to create or manipulate its objects directly.

What are the Two Important Properties of Encapsulation in OOPS?

Yes, encapsulation in OOPS does group data and methods – but it’s more than that. It also brings a set of rules that govern how information is protected and concealed. By applying these rules, you can keep sensitive parts of your code safe while still allowing valid interactions through designated access points. 

Here are two core properties that make this process effective:

1. Data Protection

Data Protection focuses on guarding sensitive variables behind class boundaries. For example, you might place details like passwords or bank balances in a private section of the class and then offer only controlled functions for reading or updating those details.

This approach reduces the risk of mistakes and unauthorized changes since you control how outside code interacts with the data.

Let’s understand this with the help of an example code.

In the following Java example, a BankAccount class uses private fields for balance and allows only controlled operations on that balance.

• Private balance is defined.
• Public methods deposit, withdraw, and getBalance handle valid operations on that balance.

public class BankAccount {
    private double balance;
    
    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            balance = initialBalance;
        } else {
            balance = 0;
        }
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) {
        if (amount <= balance && amount > 0) {
            balance -= amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

Output:

120.0

Why it helps: Direct access to balance is blocked. You control deposits and withdrawals through the class’s own methods, which means no external code can set an invalid balance.

2. Information Hiding

Information Hiding goes one step further by concealing not just the data but also any internal implementation. You only reveal the methods or interfaces that someone needs to accomplish tasks with your class. 

This separation lets you modify or improve the internal code later without affecting anything that relies on those public interfaces. It also keeps your overall design simpler for anyone using the class.

Let’s understand this with the help of an example code.

In this C++ example, a Student class includes hidden logic for validating age and makes that logic available only through public methods.

• A private helper method, isValidAge, checks age validity. 
• The setDetails method uses this helper method before saving any age value.

#include <iostream>
using namespace std;

class Student {
private:
    string name;
    int age;
    // Internal logic for validating data
    bool isValidAge(int a) {
        return (a > 0 && a < 150);
    }

public:
    // Public interface
    void setDetails(string n, int a) {
        name = n;
        if (isValidAge(a)) {
            age = a;
        } else {
            age = 0;
        }
    }

    void display() {
        cout << "Name: " << name << "\nAge: " << age << endl;
    }
};

int main() {
    Student s;
    s.setDetails("Rahul", 25);
    s.display();
    return 0;
}

Output: 

Name: Rahul
Age: 25

Why it helps: By exposing only setDetails and display, you can change how age is validated or stored later without breaking any external code.

How Does Encapsulation in OOPS Work? Learn With Examples

As you know, encapsulation ensures that data stays hidden unless a user is allowed to see it. You define how data is accessed and manipulated through a clear set of rules, which keeps your classes organized. 

Once you lock in these rules, you protect internal details while letting other parts of your program interact with the data through specific methods.

Here’s a clear step-by-step guidance on how encapsulation in OOPS works:

1. Identify Data and Methods: Choose which variables or properties you want to hide and decide which operations need public access.
2. Set Access Levels: Make important attributes private (or protected) to prevent direct changes. Expose only the methods that perform controlled tasks, such as setters and getters.
3. Validate Inputs: Write checks in your setter methods to catch invalid data before it updates the hidden variables.
4. Restrict Entry Points: Keep any sensitive functions private. Only allow other class methods or child classes (if relevant) to call them.

Now, let’s understand the working of encapsulation in OOPS with an example.

Below is a Java example that follows these steps and shows how encapsulation looks in practice:

• A private marks field ensures no one can directly write random values into it.
• The setter setMarks checks if the provided number is valid, then assigns it or sets a default.

Rahul’s marks default to 0 in this snippet since 120 didn’t fit the allowed range. That’s the power of encapsulation: you’re free to enforce strict rules and keep your data in a healthy state.

// File: Student.java
public class Student {
    private String name;
    private int marks;

    public Student(String n, int m) {
        name = n;
        setMarks(m); // Uses setter for validation
    }

    public void setMarks(int m) {
        if (m >= 0 && m <= 100) {
            marks = m;
        } else {
            marks = 0; // default if invalid
        }
    }

    public int getMarks() {
        return marks;
    }

    public String getName() {
        return name;
    }
}

// File: Demo.java
public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student("Aditi", 85);
        System.out.println(s1.getName() + " => " + s1.getMarks());

        Student s2 = new Student("Rahul", 120); // Invalid
        System.out.println(s2.getName() + " => " + s2.getMarks());
    }
}

Output: 

Aditi => 85
Rahul => 0

In the coming sections, you’ll learn how to implement encapsulation in C++, Java, and Python. But before you can do that, you must understand that access modifiers differ in all these languages. Explore how!

Different Access Modifiers in C++, Java, and Python

Here’s a quick snapshot table citing the differences. Check it out to easily understand how encapsulation is implemented in these programming languages. . 

That said, let’s dive into their implementation through examples.

Encapsulation in C++: How is it Done + Example

Encapsulation in C++ controls which parts of your code can access or modify data, keeping everything organized and safe. You often rely on private or protected members for sensitive details, then add public methods to handle valid interactions. This avoids unwanted changes and keeps your classes easy to maintain.

Here are some steps you can follow:

• Identify Important Data: Decide which variables need to be shielded from direct access, like scores or balances.
• Use Private or Protected: Mark those variables as private if no other classes should touch them or protected if subclassing might require controlled access.
• Create Public Methods: Provide setters and getters that validate input or enforce rules before any data gets stored or retrieved.
• Add Internal Checks: Keep logic that the outside world doesn’t need in private functions. This way, only your class methods can call them.

Example: Encapsulating a Student’s Details

Here, encapsulation prevents random external code from assigning negative or impossible values to marks. Thus, you maintain full control over valid data and guard against accidental errors.

• A Student class stores name and marks as private.
• Setters and getters manage those values.
• The main function creates objects and shows how data is safely read and written.

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    string name;
    int marks;

    bool isValidMarks(int m) {
        return (m >= 0 && m <= 100);
    }

public:
    void setName(string n) {
        name = n;
    }

    void setMarks(int m) {
        if (isValidMarks(m)) {
            marks = m;
        } else {
            marks = 0; // default if invalid
        }
    }

    string getName() {
        return name;
    }

    int getMarks() {
        return marks;
    }
};

int main() {
    Student s1, s2;
    
    s1.setName("Ravi");
    s1.setMarks(88);

    s2.setName("Priya");
    s2.setMarks(120); // invalid, gets set to 0

    cout << s1.getName() << " => " << s1.getMarks() << endl;
    cout << s2.getName() << " => " << s2.getMarks() << endl;

    return 0;
}

Output: 

Ravi => 88
Priya => 0

You can also study OOPS concepts in C++ to further expand your understanding of making software applications secure.

Encapsulation in Java: How is it Done + Example

Encapsulation in Java revolves around declaring your key data as private and then using public methods for controlled access. This way, you can insert checks, logs, or any additional logic without letting external code meddle with the underlying details. It’s a clean way to guard information while keeping classes flexible for future changes.

Here are some steps you can follow:

• Declare Private Fields: Choose fields like balance or age that shouldn’t be modified directly.
• Create Public Setters: Provide methods that validate data before storing it. For example, you can reject negative values or set a default.
• Add Public Getters: Allow read-only access through these methods. This is handy if you need to convert or process data before returning it.
• Keep Internal Checks: If your class requires helper methods that the outside world shouldn’t call, keep them private. That preserves clarity for anyone using the class.

Example: Encapsulating an Employee’s Details

In this code, you control every update to an employee’s salary while keeping the logic simple and centralized. If you ever decide to adjust the calculation or add error messages, the rest of your program remains unchanged.

• A private salary field ensures no one sets or retrieves its value without the class’s supervision.
• The setSalary method checks for valid input, and the getSalary method returns the approved salary.

// File: Employee.java
public class Employee {
    private String name;
    private double salary;

    public Employee(String n, double initialSalary) {
        name = n;
        setSalary(initialSalary); // Uses the setter for validation
    }

    public void setSalary(double amount) {
        if (amount >= 0) {
            salary = amount;
        } else {
            salary = 0;
        }
    }

    public double getSalary() {
        return salary;
    }

    public String getName() {
        return name;
    }
}

// File: Demo.java
public class Demo {
    public static void main(String[] args) {
        Employee emp1 = new Employee("Reema", 45000);
        System.out.println(emp1.getName() + " => " + emp1.getSalary());

        Employee emp2 = new Employee("Nikhil", -100);
        System.out.println(emp2.getName() + " => " + emp2.getSalary());
    }
}

Output:

Reema => 45000.0
Nikhil => 0.0

Need further clarification? Check out the OOPS Concept in Java Explained for Beginners to better grasp the subject. 

Encapsulation in Python: How is it Done + Example

Encapsulation in Python takes a less strict approach compared to languages like C++ or Java, but you can still structure your code so that only approved methods touch important data. 

Typically, you rely on naming conventions — especially prefixing an attribute with double underscores — to signal that it’s meant for internal use. You then supply property getters or regular methods to handle valid changes.

Here are a few steps to keep in mind:

• Use Naming Conventions: Prefix private attributes with __ (e.g., __salary). Although Python won’t prevent direct access, the double underscores discourage unauthorized changes.
• Provide Getter and Setter Methods: Let other parts of your code call these public methods to retrieve or modify your hidden variables. Add checks to keep values within sensible limits.
• Keep the Logic Clear: Tuck those details inside private methods if you need extra validation or formatting. You can rename them using double underscores so they stay out of sight to outsiders.

Example: Encapsulating Details in a Python Class

In this code, while Python won’t block you from accessing __salary if you try hard enough, this pattern signals the right way to interact with employee data and keeps your code neatly organized.

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.__salary = 0
        self.set_salary(salary)

    def set_salary(self, amount):
        if amount > 0:
            self.__salary = amount
        else:
            self.__salary = 0

    def get_salary(self):
        return self.__salary

# Example usage:
if __name__ == "__main__":
    emp = Employee("Raj", 30000)
    print(emp.name, "=>", emp.get_salary())

    emp.set_salary(-500)  # Invalid, defaults to 0
    print(emp.name, "=>", emp.get_salary())

Output:

Raj => 30000
Raj => 0

Also Read: A Complete Guide on OOPs Concepts in Python

What are the Advantages and Disadvantages of Encapsulation in OOPS?

Encapsulation brings clear boundaries to how data is accessed, which can help you reduce errors and keep your code more organized. However, it also comes with certain trade-offs you need to consider before deciding how strictly to lock down each part of your system.

Let’s explore both!

Advantages of Encapsulation in OOPS

Here’s a tabulated snapshot of the benefits of encapsulation in OOPS. 

Disadvantages of Encapsulation in OOPS

Here’s a summary of the pitfalls of encapsulation you must know.

What are the Real-world Analogies of Encapsulation in OOPS?

Encapsulation isn’t just a programming principle. You can spot it in everyday situations where the inside workings of a system are hidden, and only a limited set of actions is offered to the outside world. Seeing these parallels can help you grasp how encapsulation in OOPS secures data and keeps processes efficient.

Below are a few examples that highlight the concept.

1. Sales Department Analogy

In a company's sales department, data like customer records, sales figures, and contracts are handled by a team, but not everyone has access to it.

Encapsulation Example:

• The sales department (class) bundles customer records (data) and sales processing (methods) into a single unit.
• Only authorized staff, such as account managers, can view or update customer records through specific tools (methods), preventing unauthorized changes.
• Internally, the system validates changes before updating sensitive data.

2. ATM Machine

An ATM is a great analogy for encapsulation, as it hides the complexities of its internal processes while exposing limited, user-friendly functionality.

Encapsulation Example:

• The ATM (class) bundles data like account balance and methods like cash withdrawal, deposit, and balance inquiry.
• Users interact only through the ATM's interface (methods), while the internal details like transaction processing and security checks are hidden.
• The system ensures that withdrawals are allowed only within the account's balance limit, enhancing security and error prevention.

3. Car Engine System

A car's engine is encapsulated within the vehicle, with only specific controls exposed to the driver.

Encapsulation Example:

• The engine (class) includes components like pistons and fuel injectors (data) and functions like ignition and acceleration (methods).
• Drivers interact with the car via controls like the accelerator and ignition switch (public methods) without directly accessing internal components.
• Encapsulation ensures the driver cannot inadvertently damage internal systems while allowing controlled functionality.

How Does Encapsulation Compare to Other 3 Pillars of OOPS?

Object-Oriented Programming (OOP) is built upon four fundamental principles, often referred to as pillars, that guide software design and promote code reusability, maintainability, and scalability. 

These pillars are Abstraction, Encapsulation, Inheritance, and Polymorphism. Each plays a vital role in creating robust and well-structured applications. 

Let's dive into how encapsulation compares with the other three pillars.

1. Encapsulation vs Abstraction

Abstraction simplifies complex systems by modeling classes appropriate to the problem and working at a suitable level of complexity. It involves hiding the complex implementation details and exposing only the essential information about an object. This allows developers to focus on what an object does rather than how it achieves it.

Here’s how it differs from encapsulation:

2. Encapsulation vs Inheritance

Inheritance is a mechanism where a new class acquires the properties and behaviors of an existing class. It promotes code reuse by allowing you to create new classes based on existing ones, inheriting their attributes and methods. This establishes a hierarchical relationship between classes, where subclasses inherit from superclasses.

Here’s how it compares with encapsulation in OOPS.

3. Encapsulation vs Polymorphism 

Polymorphism is the ability of an object to take on many forms. More specifically, polymorphism means that a call to a member function will cause a different function to be executed depending on the type of object that invokes the function. It enables you to write code that can work with objects of different classes in a uniform way.

Here’s how it differs from encapsulation in OOPS.

Here’s a quick comparison between encapsulation and other OOPs Pillars:

How Can upGrad Help You?

Software designers with enhanced skills in encapsulation in OOPS are in great demand these days. If you are a Python, Java or C++ developer, then learning about encapsulation in object-oriented programming can be an asset to your resume. 

upGrad offers numerous courses on encapsulation in OOPS that will help you make your software programs secure and reliable. Here are some of the most popular courses that can help you to learn about encapsulation in OOPS: 

• AI-Powered Full Stack Development Course by IIITB
• Professional Certificate Program in AI and Data Science
• Master the Cloud and Lead as an Expert Cloud Engineer
• Cloud Computing and DevOps Program by IIITB - (Executive)
• Learn Basic Python Programming
• Programming with Python: Introduction for Beginners
• Learn Python Libraries: NumPy, Matplotlib & Pandas
• Case Study using Tableau, Python and SQL

Looking for more help with your career plans? upGrad offers free career counseling. These sessions can help you make wise decisions about your career goals.

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired  with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles