ANS 2- Certainly, I will you define a class representing a communication network node, implement

encapsulation using private and protected members, provide getter and setter methods, and explain
the advantages of encapsulation and access control in maintaining data integrity.

Defining a Communication Network Node Class:

Let's create a class called `NetworkNode` to represent a communication network node. This class will
include attributes related to its configuration and functionality, such as IP address, port number, and
status.

```python

class NetworkNode:

def __init__(self, node_id, ip_address, port):

self.__node_id = node_id # Private attribute

self._ip_address = ip_address # Protected attribute

self._port = port # Protected attribute

self.__status = "Disconnected" # Private attribute

# Getter methods for private and protected attributes

def get_node_id(self):

return self.__node_id

def get_ip_address(self):

return self._ip_address

def get_port(self):

return self._port

def get_status(self):

return self.__status

# Setter methods for private and protected attributes

def set_ip_address(self, new_ip):

 self._ip_address = new_ip

def set_port(self, new_port):

self._port = new_port

def connect(self):

self.__status = "Connected"

def disconnect(self):

self.__status = "Disconnected"

def __str__(self):

return f"Node ID: {self.__node_id}, IP Address: {self._ip_address}, Port: {self._port}, Status:

{self.__status}"

```

Explanation of the Class:

- We have defined a `NetworkNode` class with attributes `__node_id`, `_ip_address`, `_port`, and
`__status`. Attributes with a double underscore (e.g., `__node_id`) are private, while those with a
single underscore (e.g., `_ip_address` and `_port`) are protected.

- Private attributes are accessed using getter and setter methods, which provide controlled access to
the data.

- We have provided getter methods (`get_node_id`, `get_ip_address`, `get_port`, and `get_status`) to

retrieve the values of private and protected attributes.

- Setter methods (`set_ip_address` and `set_port`) allow modification of protected attributes,

ensuring controlled access and data integrity.

- The `connect` and `disconnect` methods modify the `__status` attribute, demonstrating
encapsulation by controlling access to internal data.

Advantages of Encapsulation and Access Control:

1. Data Integrity: Encapsulation ensures that data remains consistent and valid by controlling
access to it. Private and protected attributes can only be modified through controlled methods
(setters), reducing the risk of data corruption.
2. Hide Implementation Details: Encapsulation hides the internal implementation details of a class.
Users of the class interact with it through a well-defined interface (public methods), which shields
them from the complexity of the internal workings.

3. Flexibility: By using getter and setter methods, you can change the internal representation of
data without affecting the external interface. This provides flexibility in adapting the class to
changing requirements.

4. Security: Encapsulation enhances security by preventing unauthorized access to sensitive data.

Private attributes are not directly accessible from outside the class, making it harder for malicious
code to tamper with data.

5. Code Maintenance: Encapsulation makes code easier to maintain and debug. When changes are
needed, they can be localized to the class's methods, reducing the risk of unintended side effects in
other parts of the code.

6. Code Reusability: Encapsulated classes can be reused in different contexts without modification
because their interface remains consistent. This promotes code reusability and modularity.

7. Enforcement of Business Rules: With encapsulation, you can enforce business rules and
constraints on data modification. For example, you can validate input before allowing changes to an
attribute.

8. Team Collaboration: In a team environment, encapsulation allows multiple developers to work

on different parts of a program without interfering with each other's code. They can rely on the
class's public interface.

Examples of Encapsulation:

Let's demonstrate how encapsulation and access control work with an example:

```python

# Creating a network node instance

node1 = NetworkNode("001", "192.168.1.1", 8080)

# Accessing attributes through getter methods

print("Node ID:", node1.get_node_id()) # Private attribute

print("IP Address:", node1.get_ip_address()) # Protected attribute

print("Port:", node1.get_port()) # Protected attribute

print("Status:", node1.get_status()) # Private attribute

# Modifying attributes through setter methods

node1.set_ip_address("10.0.0.1") # Protected attribute modified through setter

node1.set_port(9090) # Protected attribute modified through setter

node1.connect() # Private attribute modified through a method

# Displaying the updated node information

print("Updated Node Information:")

print(node1)

# Attempting to access private attributes directly (will result in an error)

# print(node1.__node_id) # Raises AttributeError

# print(node

1.__status) # Raises AttributeError

```

In this example, we create a `NetworkNode` instance, access its attributes through getter methods,
modify protected attributes through setter methods, and demonstrate that private attributes cannot
be accessed directly. This encapsulation ensures controlled and secure access to the class's data
while maintaining data integrity and a well-defined interface for users of the class.

Conclusion:

Encapsulation is a fundamental concept in object-oriented programming that promotes data

integrity, code organization, and security. By encapsulating data through private and protected
attributes and providing controlled access through getter and setter methods, we can hide
implementation details, enforce business rules, and ensure that data remains consistent and secure.
Encapsulation enhances code maintainability, reusability, and collaboration, making it a crucial
concept in software development.