Encapsulation in object-oriented programming is like wrapping up an object and keeping its internal details hidden from the outside world. It’s a way of organizing code so that the implementation of an object is shielded, and only a well-defined interface is exposed to interact with it. Let’s break down encapsulation with a simple example:
Imagine we have an object called ‘Employee.’ This object has a hidden attribute, let’s say ‘salary.’ Now, we don’t want other parts of the program directly messing with or knowing about the salary. We want a controlled way to access this information. That’s where encapsulation comes in.
- Separating External and Internal Aspects:
- External aspects: These are the things other objects can interact with, like methods.
- Internal implementation details: These are the hidden attributes and methods within the object.
- Preventing Ripple Effects:
- If we change how the salary is calculated or stored inside the ‘Employee’ object, we don’t want it to affect every other part of the program. Encapsulation helps in minimizing these ripple effects.
- Changing Implementation Without Impact:
- If we need to improve performance, fix a bug, or make any changes to how ‘Employee’ works internally, we can do that without affecting other parts of the program.
- Example with ‘Employee’ Object:
- The ‘salary’ attribute is kept hidden inside the ‘Employee’ object.
- Other objects can only access the salary through a specific method, let’s call it ‘getSalary().’
- The method resides within the ‘Employee’ object, and it acts as a gatekeeper for accessing the salary.
- Message Passing to Access Data:
- In the diagram think of ‘getSalary()’ as a message. Other parts of the system can send this message to the ‘Employee’ object.
- The object responds to the message by providing the salary.
- This way, the internal details, like how the salary is stored or calculated, remain hidden.