The Four Pillars of Java - Part 2 - Encapsulation

Encapsulation is one of the four fundamental concepts of object-oriented programming (OOP), the others being inheritance, polymorphism, and abstraction. In Java, encapsulation is a mechanism that bundles data (attributes or fields) and methods (functions) that operate on the data into a single unit known as a class. It also restricts direct access to some of the object's components, providing control over the data stored in an object.

The main goals of encapsulation in Java are:

1. Data Hiding: Encapsulation allows you to hide the internal details and state of an object from the outside world. You achieve this by declaring the fields of a class as `private`, which means they can only be accessed within the same class. This prevents external code from directly modifying or accessing the object's internal data, ensuring data integrity and reducing the risk of unintended side effects.

   Example:

   public class Person {
       private String name;
       private int age;

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }

       public int getAge() {
           return age;
       }

       public void setAge(int age) {
           if (age >= 0) {
               this.age = age;
           }
       }
   }
  

   In this example, the `name` and `age` fields are encapsulated, and their access is controlled through getter and setter methods.

2. Controlled Access: By providing public methods (getter and setter methods) to access and modify the encapsulated data, you can enforce certain rules or constraints. This allows you to validate and control the data before it is stored or retrieved.

   In the `Person` class example above, the `setAge` method ensures that the `age` is set only if it's a non-negative value.

3. Flexibility: Encapsulation allows you to change the internal implementation of a class without affecting the code that uses the class. Clients of the class interact with it through its public interface, and they don't need to be aware of how the data is stored or manipulated internally.

   Example:

   You can change the internal representation of the `Person` class (e.g., storing `age` as a `Date` instead of an `int`) without affecting the code that uses the `Person` class, as long as the public interface remains the same.

4. Information Hiding: Encapsulation promotes the concept of information hiding, where the internal details of a class are hidden from external code. This reduces complexity and makes it easier to maintain and evolve the codebase.

In summary, encapsulation in Java is a fundamental OOP concept that involves bundling data and methods into a class, controlling access to the data, and providing a well-defined public interface for interacting with objects. It enhances code modularity, data integrity, and flexibility, and it plays a crucial role in building robust and maintainable software systems.