Encapsulation

Encapsulation in Java is an object-oriented programming concept that bundles data and the methods that operate on that data into a single unit, such as a class. It also helps control access to the object's internal state by restricting direct access and providing controlled ways to read or modify it.

  • Usually uses private fields to restrict direct access.
  • Provides controlled access through methods such as getters and setters when required.
  • Allows validation and other rules to be applied before changing data.

How Encapsulation is Achieved in Java

Encapsulation is commonly implemented by:

  • Declaring fields as private.
  • Providing public or appropriately accessible methods to read or modify the fields.
  • Adding validation inside methods when necessary.
  • Keeping the internal implementation hidden from code outside the class.

Example: Encapsulation in Java

`class Student {

// Private variables private String name; private int age; // Setter method public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } // Getter methods public String getName() { return name; } public int getAge() { return age; }

}`

`public class Main {
public static void main(String[] args) {

 Student s1 = new Student(); // Setting values s1.setName("Gowtham"); s1.setAge(21); // Getting values System.out.println(s1.getName()); System.out.println(s1.getAge()); }

}`

Output:

Gowtham
21

Advantages of Encapsulation

  • Protects an object's internal data from direct access.
  • Allows validation before data is modified.
  • Makes code easier to maintain and modify.
  • Keeps related data and methods together in one class.
  • Reduces dependency on the internal implementation of a class.
  • Provides better control over how an object's state can be accessed or changed.

Limitations of Encapsulation

  • Can increase the amount of code when many accessor methods are required.
  • May add unnecessary complexity for very simple classes.
  • Requires careful design to decide which data and operations should be exposed.
  • Excessive use of getters and setters can expose more of a class's internal state than necessary.