Java | Private methods in interfaces

Java 9 introduced a new feature called “private methods in interfaces”, which allows developers to declare private methods in interface definitions. Before Java 9, interfaces only supported public and abstract methods. However, this new feature provides more flexibility and functionality to interfaces in Java programming.

In this article, we will explore the concept of private methods in interfaces and demonstrate how they can be used in Java 9.

What are Private Methods in Interfaces?

Private methods in interfaces are methods that are declared private within the interface definition. These methods are not visible to the implementing classes or any other interface, and can only be accessed by default and static methods in the same interface.

The purpose of private methods in interfaces is to provide a way to encapsulate and reuse code within the interface without exposing it to the implementing classes. This makes the interface design more robust and easier to maintain.

Syntax of Private Methods in Interfaces:

To declare a private method in an interface, the “private” keyword must be used before the method definition, followed by the method signature. The method must be defined as either default or static to be accessible from other methods in the interface.

Here’s an example of a private method declaration in an interface:

public interface MyInterface {
    default void myPublicMethod() {
        // ...
        myPrivateMethod();
        // ...
    }
    
    private void myPrivateMethod() {
        // ...
    }
}

In the above example, we declare a private method “myPrivateMethod()” in the interface “MyInterface”. The method can only be accessed by the default method “myPublicMethod()” within the same interface.

Usage of Private Methods in Interfaces:

The main usage of private methods in interfaces is to avoid code duplication and promote code reuse within the interface. Private methods can be used to implement common functionality that is shared by multiple methods in the interface.

Here’s an example of using private methods in an interface:

public interface MyInterface {
    default void methodA() {
        // ...
        methodB();
        // ...
    }
    
    default void methodB() {
        // ...
        myPrivateMethod();
        // ...
    }
    
    private void myPrivateMethod() {
        // ...
    }
}

In this example, we declare two default methods “methodA()” and “methodB()” in the interface “MyInterface”. Both methods call the private method “myPrivateMethod()” to perform some common functionality.

Advantages of Private Methods in Interfaces:

1. Encapsulation: Private methods in interfaces promote encapsulation of code by hiding the implementation details of the interface from the implementing classes.
2. Code reuse: Private methods can be used to implement common functionality that is shared by multiple methods in the interface, promoting code reuse and reducing code duplication.
3. Better maintainability: Private methods in interfaces make the interface design more robust and easier to maintain by providing a way to encapsulate and reuse code within the interface.

Disadvantages of Private Methods in Interfaces:

1. Increased complexity: Private methods in interfaces can increase the complexity of the interface design, making it more difficult to understand and maintain.
2. Limited accessibility: Private methods can only be accessed by default and static methods in the same interface, limiting their accessibility to the implementing classes.

Conclusion:

Private methods in interfaces are a powerful new feature in Java 9 that can help to improve the design and maintainability of interfaces. They allow developers to encapsulate and reuse code within the interface while hiding the implementation details from the implementing classes. However, they can also increase the complexity of the interface design and limit their accessibility to the implementing classes. It’s important to weigh the advantages and disadvantages and use them judiciously in the interface design.