Encaptulation

1. 1. Private Fields: The class person has two private fields: name and age. These fields are not directly accessible from outside the class, which is a crucial aspect of encapsulation. Other classes or code cannot directly modify or read these fields.
   2. Getter Methods: The class provides public getter methods to access the private fields. For the name field, the getter method getName() returns the value of the name For the age field, the getter method getAge() returns the value of the age field.
   3. Setter Methods: The class also provides public setter methods to modify the private fields. For the name field, the setter method setName(String name) takes a String parameter name and sets the value of the name field to the provided value. For the age field, the setter method setAge(int age) takes an int parameter age and sets the value of the age field to the provided value.

   By providing getter and setter methods, the class allows external code to access and modify the name and age fields indirectly, while still maintaining control over the data. If necessary, the class can add more logic to the getter and setter methods to impose restrictions or validation criteria.

   To guarantee that the supplied age is a positive number and is within a suitable range, for instance, the class can include logic in the setter method setAge(int age). Similarly, the setter method setName(String name) could check if the provided name is not empty or null.

   Overall, this is a simple example of encapsulation in Java, and it demonstrates how you can protect the internal data of a class and provide controlled access to it through well-defined interfaces (getter and setter methods).

   You must first construct an instance (object) of the Person class in order to use it and invoke its methods. Once the object is formed, you can access and alter the private fields (name and age) using its getter and setter methods. Here’s how you can do it:

How does encapsulation work?

Encapsulation involves combining data attributes and their associated methods into a cohesive unit, commonly referred to as a class. The structure and behavior of objects that belong to a class are defined by the class, which acts as a blueprint or template. A class’s encapsulation acts as a barrier, keeping outside observers from seeing into its internal workings. It orchestrates access to the class’s inner workings through precisely defined interfaces, maintaining the integrity and security of its data and functionality.

Here’s how encapsulation works in Java:

1. Access Modifiers: In Java, access modifiers are used to control the visibility of class members (fields and methods) from outside the class. The four access modifiers are public, protected, default(package-private), and private.
   • public: Members with this modifier are accessible from any other class.
   • protected: Members with this modifier are accessible within the same package and subclasses (even if they are in a different package).
   • default(package-private): Members with no explicit access modifier are accessible only within the same package.
   • private: Members with this modifier are accessible only within the same class.
2. Private Fields: Encapsulation primarily revolves around the practice of setting class fields (data members) to a private visibility level, ensuring data protection and control. By doing so, these fields are not directly accessible from outside the class, and their values can only be read or modified through methods provided by the class (getter and setter methods).
3. Getter and Setter Methods: Public getter and setter methods, often referred to as accessors and mutators, serve the purpose of offering controlled access to private fields. They grant external code the ability to both retrieve and update the private field values, while also enabling the class to enforce validation rules or other operations as needed.
4. Data Integrity and Validation: By encapsulating the data and providing controlled access through setter methods, the class can ensure that the data adheres to specific rules and constraints. For example, a class might enforce that a certain field can only accept positive integers or that a string field must not be empty.

Encapsulation is essential for maintaining the integrity of the class’s data and protecting it from accidental or unauthorized modifications. It also empowers the class to adapt and modify its internal workings without causing disruptions to the code that relies on the class’s public interface. Users of the class don’t need to know anything about the internal workings of the class; they just need to know how to interact with its public methods.

When it comes to object-oriented programming, encapsulation is similar to the magic ingredient that makes your code stronger, clearer, and less prone to errors. It’s all about tucking away the inner workings of your objects to keep your code tidy and safe. This division of responsibilities protects your code from inadvertent hiccups and bugs while also making it easier to read. In a nutshell, encapsulation is your trusty tool for maintaining well-structured and hassle-free code.

Access Modifiers with a table chart