Encapsulation in Java

In Java, encapsulation is one of the four fundamental object-oriented programming concepts, alongside inheritance, polymorphism, and abstraction. It refers to the idea of bundling the data (fields) and the methods that operate on the data into a single unit, i.e., a class, while also controlling the access to the data by making fields private and using public methods to access or modify them.

Steps for Encapsulation:

  1. Make fields (variables) private to restrict direct access from outside the class.
  2. Provide public getter and setter methods to allow controlled access to those private fields.

Benefits of Encapsulation:

  • Data Hiding: Protects the internal state of the object from outside interference and misuse.
  • Control Over Data: You can control how the data is accessed or modified (e.g., validation inside setter methods).
  • Flexibility and Maintainability: Changes to the internal implementation can be made without affecting other parts of the program that use the class.
Example Code:

Here’s a simple example demonstrating encapsulation using private fields and public getter/setter methods:

        
        public class Person {
            // Private fields
            private String name;
            private int age;

            // Constructor
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }

            // Public getter for name
            public String getName() {
                return name;
            }

            // Public setter for name
            public void setName(String name) {
                this.name = name;
            }

            // Public getter for age
            public int getAge() {
                return age;
            }

            // Public setter for age
            public void setAge(int age) {
                // Validation: only allow positive ages
                if (age > 0) {
                    this.age = age;
                } else {
                    System.out.println("Age must be positive.");
                }
            }

            // Method to display person's details
            public void displayPerson() {
                System.out.println("Name: " + name + ", Age: " + age);
            }
        }

        public class Main {
            public static void main(String[] args) {
                // Create an object of Person
                Person person = new Person("John", 25);

                // Access data through getter methods
                System.out.println("Name: " + person.getName());
                System.out.println("Age: " + person.getAge());

                // Modify data through setter methods
                person.setName("Alice");
                person.setAge(30);

                // Display the updated details
                person.displayPerson();
            }
        }
Explanation:
  1. Private Fields:
    • name and age are private, which means they cannot be directly accessed or modified from outside the Person class.
  2. Public Getter Methods:
    • getName() and getAge() allow outside code to read the values of the private fields.
  3. Public Setter Methods:
    • setName(String name) and setAge(int age) allow outside code to modify the values of the private fields.
    • In the setAge() method, there's an example of validation to ensure that the age must be positive before changing the field's value.
Output:
        
        Name: John
        Age: 25
        Name: Alice
        Age: 30