How To Do Encapsulation In Java 

In this tutorial, we will talk about on How To Do Encapsulation In Java. This is a continuance of the previous topic, entitled Abstraction.

What is Encapsulation in Java?

Encapsulation is an important part of object-oriented programming (OOP).

How To Do Encapsulation In Java 
How To Do Encapsulation In Java 

Java Encapsulation is the idea of putting data and methods that work on that data into a single unit, like a Java class. This idea is also often used to hide from the outside what an object looks like or how it works on the inside. This is called Data Hiding.

How to Cross Hatch a Cube in Pen
How to Cross Hatch a Cube in Pen

For instance, an object might possess a quality that is hidden from the outside. You put it in a package with methods that let you read or write to it. Encapsulation lets you hide certain information and control who can see what’s going on inside an object.

How do you achieve Encapsulation in Java?

  • Set class to private variables
  • Make public setter and getter methods available for modifying and viewing variable values

Example

The following is an example of how to achieve Encapsulation in Java.

// program created by Glenn

public class EncapTest {

   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;

   }

}

The public setYYY() and getYYY() methods of the EncapTest class can be used to get to the instance variables. These methods are usually called “getters” and “setters.” So, if a class wants to use a variable, it should use these getters and setters.

The following code can be used to access the EncapTest class variables.

public class RunEncap {



   public static void main(String args[]) {

      EncapTest encap = new EncapTest();

      encap.setName("Glenn Magada Azuelo");

      encap.setAge(26);

      encap.setIdNum("AGM021596");



      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());

   }

}

Output

This will result in the following.

Name : Glenn Magada Azuelo Age : 26

Benefits of Encapsulation in Java

The following are benefits of encapsulation in Java. Here’s what they are:

  • The code that is encapsulated is more flexible and easier to change to meet new needs.
  • It keeps the private fields from being accessed by other classes.
  • Modifying implemented code is made possible by encapsulation without affecting other implemented code.
  • It prevents unauthorized usage of data and codes. Encapsulation improves safety.
  • It makes the application easier to maintain.
  • The fields can be turned read-only if the setter method is not defined in the class.
  • The fields can be made write-only if you don’t define the getter method in the class.

Tell me the meaning of Encapsulation?

The term Encapsulation refers to the grouping together of data and the methods that manipulate that data in object-oriented computer programming OOP concepts. Encapsulation is frequently used in several programming languages in the form of classes.

Example of Encapsulation in Java

In Java, encapsulation is the technique of combining code and data into a single entity.

For example, a capsule containing a variety of medications. In Java, we can make a class that is completely closed off by making all of its data class as private.

Data Hiding vs. Encapsulation in Java

In encapsulation, a variables of the class are kept hidden from other classes and can only be accessed through its methods. Because of this, it is also called data hiding. Set a class variables to be private. They have public setter and getter methods that let you change and look at the values of variables.

Encapsulation in Java

In Java, encapsulation is a way to treat data (variables) and the code that works on the data (methods) as a single unit. In encapsulation, a class variables are kept hidden from other classes, and they can only be accessed through its methods.

Data hiding in Java

In Java, you can do this by using the private keyword. This is called data hiding. It is used for security, so that no one can get to internal data without it. An end user who is not authorized will not be able to access internal data.

Why Encapsulation?

  • Encapsulation helps us keep fields and methods that are related together in Java. This makes our code cleaner and easier to read.

It help us keep track of what our data. For example,

class Level {

  private int max;



  public void setMax(int max) {

    if (max >= 0) {

      this.max = max;

    }

  }

}
  • Here, we make the max variable private and use logic within the setMax() method. The max is no longer negative.
  • The getter and setter methods allow us to access our class fields in either read-only or write-only mode. For example,
setName() // provide write-only access

getName()  // provide read-only access
  • It makes it easier to separate parts of a system. For example, we can put code into more than one bundle.

These separate parts (bundles) can be built, tested, and fixed independently and at the same time. And changes to one part have no effect on the other parts.

  • Encapsulation is another way to hide data. In the example above, if we make the length and breadth variables private, then only certain users have access to these fields.

They are also kept hidden from the upper classes. This is known as data hiding.

What are the three types of encapsulation?

The 3 types of encapsulation are listed below.

  • Member variable encapsulation
  • Function encapsulation
  • Class encapsulation

Member variable encapsulation

In Object-Oriented Programming, all of the data members that accessed within the Class in Java should be declared as private. Setters and Getters functions should be used by any object that wants to change or get the value of a data member. You may already know this as Data Member Encapsulation.

Here is an example of how setters and getters are declared in a class.

class Rectangle {

private:
    //private data member
    int diameter;

public:
    //constructor
    Rectangle();
    ~Rectangle();

    //setter function
    void setDiameter(float uValue);
    //getter function
    float getDiameter();

};

But there are other ways to encapsulate data except with data members. Functions and classes may also be encapsulated.

Member variable encapsulation

Private must always be used for API functions that are only used internally. For example, the following class is a Rectangle.

class Rectangle {

private:
    //private data member
    int diameter;

    //private method
    void calculateCircumference();

public:
    //constructor
    Rectangle();
    ~Rectangle();

    //setter function
    void setDiameter(float uValue);
    //getter function
    float getDiameter();

};

We have a setter method that changes the Diameter of a rectangle. This should be made public method because the user will provide this data.

But the CalculateCircumference() method shouldn’t be made public. This method shouldn’t be available to the user. Instead, it should be marked as a Private method. Always keep in mind that you should hiding the implementation details in any functions that the public does not need to see.

Class encapsulation

The same rule applies to classes that are used to build your API from the inside. These classes shouldn’t be included in any API’s public interface. They should be Private and hidden from your users.

For example, your API might have a class that sets a rectangle gradient color based on where it is placed. If your user doesn’t need access to this Gradient class, you should wrap it up, or declare it as a Private class, as shown below:

class Rectangle {

private:
    //private data member
    int diameter;

    //private method
    void calculateCircumference();

    //private class
    class Gradient{

        public:

        Gradient();

        ~Gradient();

        void setGradient(float uValue);

    };

public:
    //constructor
    Rectangle();
    ~Rectangle();

    //setter function
    void setDiameter(float uValue);
    //getter function
    float getDiameter();
};

Summary

In summary, you have learned about on How To Do Encapsulation In Java . This article discusses what encapsulation is in Java. How do you achieve encapsulation in Java? The benefits of encapsulation in Java, the definition of encapsulation, an example of encapsulation in Java, data hiding vs. encapsulation in Java, and the three types of encapsulation are all covered.

I hope this lesson has helped you learn a lot. Check out my previous and latest articles for more life-changing tutorials which could help you a lot.

What’s Next

The next section talks about Interfaces. At the end of the session, you’ll know what is Interfaces all about in Java.


Leave a Comment