Java Encapsulation

What is Java Encapsulation

Java encapsulation is a process where a class's variables or data are concealed from all other classes and are only accessible through member functions of the class in which they were declared. It is also known as a combination of data-hiding and abstraction because, similar to encapsulation, the data in a class is hidden from other classes using the data hiding concept, which is accomplished by making the members or methods of a class private, and the class is exposed to the end-user or the world without providing any details behind implementation.

Encapsulation is accomplished by writing public functions in the class for setting and getting the values of the variables and declaring all of the class's variables as private.

With the setter and getter methods, it is more clearly described. Encapsulation is majorly of 3 types:

• Encapsulation of member variables: All data members in object-oriented programming should be designated as class's private members. This type of encapsulation is not the sole method of data encapsulation, though. Additionally, classes and functions can be encapsulated.
• Function Encapsulation: You must always define all functions that are utilised solely internally by your API as Private. Your API's internal implementation functions must always be marked private.
• Class Encapsulation: The classes in class encapsulation shouldn't be a part of  any API's public interface. Your users should not see these, therefore make them private. For instance, your API might contain a class that, depending on a circle's position, applies a specific gradient colour to it. You should encapsulate, or define it as a Private class, if your user does not require access to this Gradient class.

Let us see a simple Java code and understand the concept of encapsulation better:

class Area_Rectangle {
int len;
int br;

Area_Rectangle(int len, int br) {
 this.len = len;
 this.br = br;
}

public void getArea() {
 int area = len * br;
 System.out.println("Area of the rectangle is: " + area);
}
}

class Main {
public static void main(String[] args) {
 Area_Rectangle rectangle = new Area_Rectangle(4, 16);
 rectangle.getArea();
}
}

Output:

Area of the rectangle is: 64

Now, let us see another Java code for encapsulation where the program demonstrated how to access the variables of the class.

class Encapsulation {
 private int age; 
 public int getAge() { return age; } 
 public void setAge(int age)
 {
 this.age = age;
 } 
}
class ABC {
 public static void main(String[] args)
 {
 Encapsulation n1 = new Encapsulation();
 n1.setAge(25);
 System.out.println("The age is: " + n1.getAge());
 }
}

Output:

The age is: 25

Wish to make a career in the world of Java? Start with HKR'S Java Training !

Need for Java Encapsulation

Let us discuss the need for encapsulation in Java:

• Encapsulation enables us to group together relevant fields and procedures, which results in cleaner, easier-to-read code.
• It makes it easier to manage the values in our data fields.
• Our class fields can be accessed read-only or write-only using the getter and setter methods.
• Decoupling system components is beneficial. For instance, we can divide code up into different bundles. It is possible to build, test, and debug this bundle of disconnected components simultaneously and independently. Additionally, any modifications to one component have no impact on the functioning of any other components.
• The data members and data methods inside the class are completely under your control thanks to encapsulation.
• Encapsulation can also be used to hide data. If we make the variables private, then access to the fields becomes restricted.

Advantages of Java Encapsulation

• Data Hiding: Encapsulation is achieved by defining all class variables as private and writing public functions in the class to set and obtain variable values. It is better explained with the help of setter and getter methods.
• Flexibility: Depending on our needs, we can make the class's variables read-only or write-only. If we want to make the variables read-only, we must remove the setter methods from the aforementioned program, such as seAge() and setName(), or if we want to make the variables write-only, we must remove the get methods, such as getAge() and getName().
• Reusability of code: Additionally, encapsulation makes it easier to reuse code and adapt to changing needs.
• Easy testing of code: For unit testing, encapsulated code is simple to test.
• Control over Data: The user can implement the logic inside the setter method if he wishes to set an ID value that must be greater than 100 alone. He can program the setter methods with logic that prevents the storage of negative integers.

   Top 30 frequently asked JAVA Interview Questions !

Data Hiding in Java

A process called as data concealing is employed to restrict access to the data methods, data members, and the logical implementation. Utilising access specifiers will enable data concealing. The following are the four access specifiers that we have :

• Default : The initial line of data concealing is default. The compiler will set "default" as the access specifier for any Java class that is not explicitly described within an access specifier. The default access specs and the public access specifier are remarkably similar.
• Public : A class's access specifications are provided by the public access specifier, enabling access to it from anywhere in the application. Check out the java program below to understand public data member :

package P;
public class X
{
public void display()
 {
 System.out.println("Welcome to HKR Trainings");
 }
}

The output of the Java code is:

Welcome o HKR Trainings

• Protected : Similar to the private specifier, the protected access specifier safeguards the class members and methods. The primary distinction is that, as opposed to only a class having the private access specifier, access is restricted to the entire package. Check out the java program below to understand protected data member :

package P;

public class X

{

protected void display()

{

System.out.println("Welcome o HKR Trainings");

}

}

• Private : The data members are accessible via the private access specifier, whereas only the class itself is accessible via the data methods. Check out the java program below to understand private data member :

package P;

class X

    {

    private void display()

{

System.out.println("Welcome to HKR Trainings);

}

}

class Y

    {

    public static void main(String args[])

{

X obj = new X();

obj.display();

}

}

The output will be:

.java
error: invalid flag: /tmp/iREEX2TaoL/Y
Usage: javac  
use --help for a list of possible options
dash: 2: .java: not found

Can multiple inheritance be achieved in Java? If not, why?

Multiple inheritance cannot be achieved in Java. This means that a Java class can only inherit from one parent class. The reason for this is that Java's design philosophy emphasizes simplicity and avoiding certain complexities that can arise with multiple inheritance.

One of the main concerns with multiple inheritance is the "diamond problem." This occurs when a class inherits from two or more classes that have a common parent class. When this happens, it can lead to ambiguity in the program because it is unclear which inherited method or attribute should be used.

To avoid the diamond problem and similar complications, Java implements a single inheritance model. This means that each class can only have one direct parent class, which helps maintain clarity and unambiguity in the code. However, Java does support implementing multiple interfaces, which allows a class to inherit multiple methods declarations from different interfaces.

What are the benefits of using inheritance in Java?

In Java, the use of inheritance offers several benefits. Firstly, it allows for the reuse of methods and fields from a parent class in a child class, making it easier to avoid code duplication and promoting a more efficient development process. By inheriting from an existing class, new classes can access and utilize the code already implemented, reducing the need for rewriting the same functionality.

Additionally, inheritance allows for the addition of new methods and fields to the child class while still having access to the inherited ones. This provides flexibility in extending the functionality of a class without modifying or altering the original code. By simply inheriting and adding new code, developers can enhance the capabilities of their classes while maintaining the integrity of the existing functionality.

Inheritance also establishes an important "IS-A" relationship between classes, where the child class is considered a specialized version of the parent class. This relationship ensures that the child class inherits all the characteristics and behavior of the parent class, allowing for a more intuitive and hierarchical structure in the code.

Another advantage of using inheritance is the ability to achieve runtime polymorphism. This means that objects of different classes can be treated and used interchangeably based on their common parent class. By utilizing inheritance, it becomes possible to create a single method or variable that can handle multiple types of objects, ultimately enhancing code reusability and promoting more efficient coding practices.

What is multilevel inheritance and how does it differ from single inheritance?

Multilevel inheritance is a concept in object-oriented programming where a chain of classes is present. It occurs when a class inherits from another class, which in turn inherits from yet another class. This creates a hierarchical structure of inheritance.

In multilevel inheritance, each derived class inherits properties and methods not only from its immediate parent class but also from all the ancestor classes in the chain. For example, in a chain of ClassA, ClassB, and ClassC, ClassC can access the properties and methods of both ClassB and ClassA.

On the other hand, single inheritance involves a single direct parent class for a derived class. In this case, each derived class inherits properties and methods only from its single parent class, and there is no further inheritance chain. This means that a single derived class can only access the properties and methods of its single parent class.

How does single inheritance work in Java?

Single inheritance in Java refers to a concept where one class can inherit the properties and methods of another class. This means that a subclass can extend a single superclass, creating a hierarchical relationship between the two classes.

In Java, the process of implementing single inheritance involves using the "extends" keyword to denote the parent class (superclass) that the child class (subclass) will inherit from. The child class can access all the public and protected members of the parent class, including methods, variables, and even nested classes.

To illustrate how single inheritance works in Java, consider the following example:

```java
class Flower {
 void sweet() {
 System.out.println("Sweet...");
 }
}

class Sunflower extends Flower {
 void nature() {
 System.out.println("Natural beauty...");
 }
}

class TestInheritance {
 public static void main(String[] args) {
 Sunflower sunflower = new Sunflower();
 sunflower.nature();
 sunflower.sweet();
 }
}
```

In this example, the `Sunflower` class inherits from the `Flower` class using the `extends` keyword. This establishes a relationship where the `Sunflower` class becomes a subclass of the `Flower` class.

As a result, the `Sunflower` class now has access to the `sweet()` method defined in the `Flower` class. Additionally, it can also define its own method called `nature()`, representing the specific characteristics of a sunflower.

In the `TestInheritance` class, we create an instance of the `Sunflower` class and call its `nature()` and `sweet()` methods. Since `Sunflower` inherits from `Flower`, it can utilize both the inherited `sweet()` method from `Flower` and its own `nature()` method.

What is inheritance in Java and why is it used?

In Java, inheritance is a mechanism that allows one class to inherit or acquire all the properties (fields and methods) of another class. It is a fundamental concept in object-oriented programming. When a class inherits from another class, it gains the ability to reuse the existing methods and fields of the parent class. Additionally, the inheriting class can add new methods and fields specific to its own needs.

Inheritance establishes an IS-A relationship between the parent and child classes. This means that the child class is a specialized version of the parent class, inheriting its characteristics and extending its functionality. For example, a "Car" class can inherit from a more general "Vehicle" class, as a car is a specific type of vehicle.

The primary purpose of using inheritance is to promote code reusability. By inheriting from a parent class, we can leverage the already implemented functionality and avoid duplicating code. This not only saves development time but also reduces the chances of introducing errors.

Another important aspect of inheritance is its role in achieving runtime polymorphism. Polymorphism allows objects of different classes to be accessed and used uniformly through a common interface. In Java, this is facilitated by inheritance, as the child classes can be treated as instances of the parent class.

Conclusion

In this article, we have discussed Java encapsulation in depth. Java encapsulation is a process where a class's variables or data are concealed from all other classes and are only accessible through member functions of the class in which they were declared. It is also known as a combination of data-hiding and abstraction. We have also discussed the need and advantages of java encapsulation along with the data hiding in java using private, public, default and protected.

Related Article : 

• What Is Java Beans
• Operators In Java
• Aspose Training
• camunda Training