This is one of the four pillars of Object-Oriented Programming. So let's dive in detail to understand what it really is.
What is Encapsulation?
Just imagine a capsule pill. The medicine inside the capsule is not exposed directly. Instead, it's encapsulated within a shell. You can only access the medicine by consuming the capsule. This ensures that the medicine is protected and delivered in the right way.
In the same way, in Java, encapsulation is like putting your data (variables) inside a protective shell (class) and controlling access to it through methods.
Now let's look at an Example.
Let's say we have a Studentclass. We want to keep the student's age private and control how it's accessed and modified.
Define the class with private fields:
- We make the
age field private so it cannot be accessed directly from outside the class.
Provide public methods to access and modify the age:
- We create public getter and setter methods to access and update the age.
Let's look at the code illustration for this.
public class Student{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 0) {
this.age = age;
} else {
System.out.println("Age cannot be negative");
}
}
}
Now, let's look how can we use the "Student" class
public class Main {
public static void main(String[] args) {
Student s1= new Student();
s1.setAge(16);
System.out.println("Student's age: " + s1.getAge());
s1.setAge(-5);
}
}
So, here we are implementing two things,
- Setting the Age:
Getting the Name:
System.out.println("Student's age: " + s1.getAge());
This line calls the getAgemethod on the studentobject. The getAgemethod returns the value of the private agefield, which is then printed to the console.
Data Hiding : The age field is private, so it cannot be accessed directly from outside the Studentclass. This means the internal state of the Studentis hidden from the outside world.
Controlled Access : We provide public methods getAge() and setAge(int age) to access and modify the age field. This allows us to add validation logic inside the setAge() method to ensure that the age cannot be set to a negative value.
Why we use Encapsulation?
There are several advantages for using Encapsulation;
Data Protection: By making fields private, you can prevent external code from changing the state of the object in unexpected ways.
Controlled Access: By providing public getter and setter methods, you can control how the internal state of an object is accessed and modified. This allows you to add validation, logging, or other logic when the state is changed.
Easy to maintain: Encapsulation helps to keep the code modular. So that every class can be developed, tested and maintained independently.
Resuability: It encourages the creation of reusable components. By exposing only the necessary details through public methods, you can create classes that can be reused across different parts of an application.
Getter and Setter Methods
We have already mentioned about the getter and setter methods above. So now lets understand what are these in detail.
In Java, getter and setter methods are used to access and modify the private fields of a class from outside the class. They are part of the encapsulation concept.
Why we use these Getter and Setter methods?
Since fields in a class are often made private to protect them from direct access, getter and setter methods provide a way to access and update these private fields indirectly. This allows for controlled access and modification.
So, let's take the same example from above and explain it again. This will help beginners understand it with more clarity.
Imagine a simple class called Studentwith a private field name.
Step - 1
Define the class with a private field.
public class Student {
private String name;
}
Here, name is a private field, meaning it cannot be accessed directly from outside the Studentclass.
Step - 2
Create setter and getter methods - to access and modify the name field.
public class Student{
private String name;
public String getName()
{
return name;
}
public String setName(){
this.name= name
}
}
Step -3
Now let's see how can we access and update the name field value in the above code.
public class Main {
public static void main(String[] args) {
Student s1= new Student();
s1.setName("Sankarlal");
System.out.println("Student's name: " + s1.getName());
}
}
Setting the Name:
Getting the Name:
System.out.println("Student's name: " + s1.getName());
This line calls the getName method on the studentobject. The getName method returns the value of the private name field, which is then printed to the console.
I think now you have a good understanding of Encapsulation and how getter and setter methods work.
