🔓Encapsulation

Encapsulation is the bundling of data and methods that operate on that data into a single unit.

If the class internals need to change, only the class methods need updating rather than external code as well.

Encapsulation allows you to hide the implementation details of a class from outside access and only expose a public interface that can be used to interact with the class.

This has several benefits, including:

• Data hiding: Encapsulation prevents other classes from directly accessing the data in a class, which can help to protect the data from unauthorized access or modification.

• Control of data: Encapsulation allows you to control how the data in a class is used. For example, you can ensure that the data is always valid or that it is only accessed in a certain way.

• Reusability: Encapsulated classes are easier to reuse in other applications because they do not expose their implementation details.

class Person {
  // **private** fields are hidden from outside access
  private String name;
  private int age;

  // **public** methods allow access to the private fields
  public void setName(String name) {
    this.name = name;
  }

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

  // A public method that prints the person's name and age
  public void sayHello() {
    System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
  }
}

Encapsulation is like a 🔐 that protects your data from unauthorized access. It allows you to control how your data is used, and it can help to prevent errors.

🚪 Public, Private, Protected

Encapsulation is achieved by using access modifiers like public, private and protected:

public class Person {

  // Private field
  private int age; 
  
  // Public getter method
  public int getAge() {
    return age;
  }
  
  // Public setter method
  public void setAge(int newAge) {
    age = newAge;
  }

}

• private restricts access to class members

• public allows unfettered access

🛡 Defining the Interface

Getters and setters define the interface to the class's private data:

person.getAge(); // Read age

person.setAge(20); // Write age

The implementation details are hidden within the class.

For example, you might want to encapsulate the age of a person in your code.

You could do this by making the age field private, and then providing public methods for setting and getting the age.

This would prevent someone from accidentally setting the age to a negative value, or from accessing the age without permission.

💡 Rules for Encapsulation in Java 👨‍💻

Encapsulation in Java follows these main rules:

• 🟢 Declare class variables as private 🔒

• 🟢 Provide public getter and setter methods to access and modify variables

private int empId; 

public int getEmpId() {
  return empId;
}

public void setEmpId(int id) {
  empId = id;
}

• 🔵 Use getters and setters to access attributes rather than directly accessing private variables

employee.setEmpId(101); 

int id = employee.getEmpId();

• 🟡 Don't allow uncontrolled access to variables

• 🔴 Subclass cannot directly access private members of superclass

• 🟣 Can allow subclass access via protected modifier

• 🟡 Use interfaces and abstract classes to better encapsulate code

• 🟢 Always think about visibility of methods and variables

Encapsulation helps control state of objects and prevents invalid data access. It's an essential principle for robust and maintainable OOP code in Java.

🔐 Key Notes

• Encapsulation bundles data and methods into a class

• The data is hidden from external access using access modifiers like private

• Getters and setters provide controlled access to the data

• This data hiding separates the class interface from implementation

Encapsulation is a powerful tool that can help you to write more secure and reliable code. It's a 🌟 skill that every programmer should learn.

So go forth and encapsulate your data! 🔐🌟