ENCAPSULATION AND DATA HIDING

Encapsulation and data hiding are important concepts in Object-Oriented Programming (OOP) that promote information hiding and data protection within classes. They provide a level of abstraction and prevent direct access to the internal data of an object. Let's explore these concepts in more detail:

1. Encapsulation: Encapsulation is the bundling of data (attributes) and methods (functions) that operate on that data within a single unit, which is the class. It is one of the four fundamental principles of OOP, along with abstraction, inheritance, and polymorphism. Encapsulation allows you to hide the internal implementation details of a class and expose only a well-defined interface for interacting with the object.

By encapsulating data and methods together, you can control the access to the object's state, preventing unauthorized modifications or direct access to the internal data. Instead, interactions with the object are performed through well-defined methods, providing a clear and controlled way to interact with the object's state.

2. Data Hiding: Data hiding is a specific aspect of encapsulation that refers to the practice of making the internal data of a class private, so it cannot be accessed or modified directly from outside the class. In Python, this is achieved by using the concept of access specifiers.

In Python, access specifiers are represented by underscores:

A single underscore _ before an attribute name indicates that the attribute is intended to be treated as private, even though it is not strictly enforced.
A double underscore __ before an attribute name causes name mangling, making the attribute more difficult to access directly from outside the class.

By using data hiding and access specifiers, you can ensure that the internal data of a class is not modified accidentally or accessed without appropriate validation and control.

Example:

python

class Person:
    def __init__(self, name, age):
        self._name = name  # Using a single underscore for data hiding
        self.__age = age   # Using a double underscore for stronger data hiding

    def get_name(self):
        return self._name

    def get_age(self):
        return self.__age

    def set_age(self, new_age):
        if new_age > 0:
            self.__age = new_age


# Creating a Person object
person = Person("Alice", 30)

# Directly accessing the attributes (not recommended)
print(person._name)    # Output: Alice (can be accessed, but not recommended)
# print(person.__age)  # Raises AttributeError (name mangling)

# Using getter and setter methods for controlled access
print(person.get_name())  # Output: Alice
print(person.get_age())   # Output: 30

# Using the setter method to modify the age attribute (controlled access)
person.set_age(35)
print(person.get_age())   # Output: 35

In this example, the Person class encapsulates the data (_name and __age) and provides getter and setter methods to access and modify the data in a controlled manner.

By following encapsulation and data hiding principles, you can create more robust and maintainable code, protecting the integrity of your objects and preventing unintended modifications.