Java Encapsulation

Hello there, fellow Java enthusiasts! Today, we’re diving into the world of Java Encapsulation. Ready to encapsulate your mind around this concept? Let’s get started!

Introduction

Java Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and abstraction. But today, we’re focusing on encapsulation. Why? Because it’s the Java way of bundling up variables and methods together within a single unit, a.k.a. a class.

Understanding Java Encapsulation

Encapsulation is like a protective shell that prevents code and data from being arbitrarily accessed by other code defined outside the shell. Think of it as a capsule (hence the name!). Inside this capsule, we have our data and methods, safe and sound from the outside world.

In the context of object-oriented programming, encapsulation is all about combining variables and methods into a single unit, known as a class. This approach helps to achieve data hiding, as the data of a class is hidden from other classes, and can only be accessed through the methods of their current class.

Java Encapsulation with Examples

Let’s take a look at how encapsulation works in Java with a simple example. Consider a class named Employee, which has three fields: name, idNum, and age. We can encapsulate these fields by declaring them as private and providing public getter and setter methods to modify and view the variables’ values.

public class Employee {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

In the above example, name, idNum, and age are encapsulated in the Employee class. This class is fully encapsulated, as its variables are declared as private and can only be accessed via getter and setter methods.

Advantages of Java Encapsulation

Encapsulation has a lot of advantages:

1. Control of data: By encapsulating the data, we have full control over what gets stored in the fields. We can add validation in the setter methods to protect the fields from being polluted with bad data.
2. Increased security: Data is hidden from the outside world, and only accessible through the methods of the current class. This ensures the integrity of the data.
3. Flexibility and maintainability: The fields can be made read-only or write-only according to our needs. If we wish to make the name read-only, we simply don’t define the setName() method.

Java Encapsulation vs Abstraction

Encapsulation and abstraction often go hand in hand in Java, but they’re not the same thing. While encapsulation is about bundling data and methods within one unit and hiding the data from the outside world, abstraction is about hiding the complexity and only showing the essential features of the object.

In other words, encapsulation is more focused on the implementation, hiding the details on how the object works. On the other hand, abstraction is more about the interface, hiding how the action is performed and showing only the necessary information.

Java Encapsulation Examples

Here are two complete code examples demonstrating Java Encapsulation:

Example 1:

public class Student {
   private String name;
   private int rollNo;

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public int getRollNo() {
      return rollNo;
   }

   public void setRollNo(int rollNo) {
      this.rollNo = rollNo;
   }
}

public class Test {
   public static void main(String[] args) {
      Student s = new Student();
      s.setName("John");
      s.setRollNo(2);
      System.out.println("Name: " + s.getName());
      System.out.println("Roll No: " + s.getRollNo());
   }
}

In this example, we have a Student class with two private fields: name and rollNo. We’re using getter and setter methods to access these fields. The Test class demonstrates how to use these methods.

Output:

Name: John
Roll No: 2

In this example, we created a Student object named s. We then set the name to “John” and the rollNo to 2 using the setter methods. When we print the name and rollNo using the getter methods, we get “John” and 2 respectively.

Run the JavaCode with IntelliJ IDEA or Visual Studio Code

Create two class files such as Student.java and Test.java which would contain the respective classes. Run the code and you will see the output.

Example 2:

public class Bank {
   private double balance;

   public double getBalance() {
      return balance;
   }

   public void deposit(double amount) {
      if(amount > 0) {
         balance += amount;
      }
   }

   public void withdraw(double amount) {
      if(amount > 0 && balance >= amount) {
         balance -= amount;
      }
   }
}

public class Test {
   public static void main(String[] args) {
      Bank myBank = new Bank();
      myBank.deposit(2000);
      myBank.withdraw(500);
      System.out.println("Balance: " + myBank.getBalance());
   }
}

In this example, we have a Bank class with a private field balance. We’re using a getter method and two other methods deposit and withdraw to manipulate the balance. The Test class demonstrates how to use these methods.

Output

Balance: 1500.0

In this example, we created a Bank object named myBank. We then deposited 2000 into the account and withdrew 500 from it. When we print the balance, we get 1500.0.

Wrapping Up

Java Encapsulation is a fundamental concept in object-oriented programming. It helps us to bundle data and methods within a single unit and hide the data from the outside world. Understanding encapsulation is crucial for any Java developer, as it forms the basis for more advanced concepts and helps to write secure and maintainable code.

Java Encapsulation Interview Questions (FAQ)

public class Employee {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

In this example, name, idNum, and age are encapsulated in the Employee class. This class is fully encapsulated, as its variables are declared as private and can only be accessed via getter and setter methods.

Related Tutorials

1. Java Abstraction: A Comprehensive Guide
2. Understanding Java Inheritance
3. Java Polymorphism Explained
4. Mastering Java Classes and Objects

That’s all, folks! I hope you found this tutorial helpful. Keep practicing and happy coding!