1. Overview
From Java 9, private methods can be added to interfaces in Java. In this short tutorial, let’s discuss how we can define these methods and their benefits.
2. Defining Private Methods in Interfaces
Private methods can be implemented static or non-static. This means that in an interface we are able to create private methods to encapsulate code from both default and static public method signatures.
First, let’s look at how we can use private methods from default interface methods:
public interface Foo {
default void bar() {
System.out.print("Hello");
baz();
}
private void baz() {
System.out.println(" world!");
}
}
bar() is able to make use of the private method baz() by calling it from it’s default method.
Next, let’s add a statically defined private method to our Foo interface:
public interface Foo {
static void buzz() {
System.out.print("Hello");
staticBaz();
}
private static void staticBaz() {
System.out.println(" static world!");
}
}
Within the interface, other statically defined methods can make use of these private static methods.
Finally, let’s call the defined default and static methods from a concrete class:
public class CustomFoo implements Foo {
public static void main(String... args) {
Foo customFoo = new CustomFoo();
customFoo.bar();
Foo.buzz();
}
}
The output is the string “Hello world!” from the call to the bar() method and “Hello static world!” from the call to the buzz() method.
3. Benefits of Private Methods in Interfaces
Let’s talk about the benefits of private methods now that we have defined them.
Touched on in the previous section, interfaces are able to use private methods to hide details on implementation from classes that implement the interface. As a result, one of the main benefits of having these in interfaces is encapsulation.
Another benefit is (as with private methods in general) that there is less duplication and more re-usable code added to interfaces for methods with similar functionality.
4. Conclusion
In this tutorial, we have covered how to define private methods within an interface and how we can use them from both static and non-static contexts. The code we used in this article can be found over on GitHub.
