Encapsulation in Java

Question

What is encapsulation in Java, and what are its key benefits in object-oriented programming?

Answer

Encapsulation is one of the four fundamental principles of Object-Oriented Programming (OOP) in Java. It refers to the bundling of data (attributes) and methods (behaviors) that operate on that data within a single unit, or class, while hiding the internal implementation details from the outside world.

Key Benefits of Encapsulation:

1. Data Hiding
2. Prevents direct access to class members from outside the class
3. Provides controlled access through getters and setters

4. Example:

   public class BankAccount {
       private double balance;  // private field
   
       public double getBalance() {  // public getter
           return balance;
       }
   
       public void setBalance(double amount) {  // public setter
           if (amount >= 0) {
               balance = amount;
           }
       }
   }
   

5. Improved Security

6. Prevents unauthorized access to sensitive data
7. Allows validation of data before modification

8. Example:

   public class User {
       private String password;
   
       public void setPassword(String newPassword) {
           if (isValidPassword(newPassword)) {
               password = hashPassword(newPassword);
           }
       }
   }
   

9. Maintainability

10. Makes code easier to maintain and modify
11. Changes to internal implementation don't affect external code

12. Example:

    public class Temperature {
        private double celsius;
    
        // Can change internal implementation without affecting users
        public double getFahrenheit() {
            return (celsius * 9/5) + 32;
        }
    }
    

13. Flexibility

14. Allows modification of internal implementation without changing external interface
15. Enables version control of APIs
16. Example:

    public class Cache {
        private Map<String, Object> storage;
    
        // Can change storage implementation without affecting users
        public void put(String key, Object value) {
            storage.put(key, value);
        }
    }
    

Best Practices:

1. Make fields private by default
2. Provide public getters and setters only when necessary
3. Use meaningful names for methods and variables
4. Implement proper validation in setters
5. Keep the interface minimal and focused

Example of Good Encapsulation:

public class Student {
    private String name;
    private int age;
    private List<Course> courses;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.courses = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name != null && !name.trim().isEmpty()) {
            this.name = name;
        }
    }

    public int getAge() {
        return age;
    }

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

    public List<Course> getCourses() {
        return Collections.unmodifiableList(courses);  // Defensive copying
    }

    public void addCourse(Course course) {
        if (course != null) {
            courses.add(course);
        }
    }
}

This example demonstrates proper encapsulation by: - Making all fields private - Providing controlled access through getters and setters - Including validation in setters - Using defensive copying for collections - Providing a clean public interface