dcsimg
 

Using Private Interface Methods in Java 9, Part 1

Friday Jun 8th 2018 by Deepak Vohra

Plunge into the private interface methods introduced in Java 9, with an example in Eclipse IDE.

Java 8 introduced default implementations for interface methods, which had been abstract only up till then. The default implementation meant that a class that implemented the interface did not have to provide an implementation for the method/s.

Problem: But, another problem still remained. If m interface methods with default implementation have n common code logic blocks, the common code logic has to be included in each of the m methods. As a result, n common code logic blocks referred in n methods with default implementation resulted in mxn code logic blocks.

Solution: Java 9 introduced private interface methods. The private interface methods could be used to encapsulate common code logic that was used in the interface methods that provided a default implementation. The common code logic could be invoked in a default implementation method in an interface. Being a private method, the common code logic cannot be overridden in a class that implements the interface. The mxn code logic blocks are reduced to n code logic blocks. As an example, two interface methods, method1 and method2, that invoked common code logic may make use of a private method, method3, to encapsulate the common code logic.

In two articles, we shall discuss the private interface methods introduced in Java 9, with an example in Eclipse IDE.

This article has the following sections:

Setting the Environment

Download and install an Eclipse edition that supports Java 9. Eclipse IDE for Java EE Developers Photon M6 package (Windows 64-bit) is used in this article. Download and install Java 9.

Creating a Java Project

First, we need to create a Java project. Select File>New>Other in Eclipse IDE, as shown in Figure 1.

File>New>Other
Figure 1: File>New>Other

In the New window, select Java>Java Project and click Next, as shown in Figure 2.

New>Java>Java Project
Figure 2: New>Java>Java Project

The Create a Java Project window gets launched, as shown in Figure 3. Specify a Project name (MagazineSubscription), and select the Use default location checkbox. The JRE should be set to JavaSE-9. For Project layout, select Create separate folders for sources and class files. Click Next.

New Java Project>Create a Java Project
Figure 3: New Java Project>Create a Java Project

In Java Settings, select Allow output folders for source folders checkbox, as shown in Figure 4. With Default output folder set to MagazineSubscription/bin, click Finish.

Java Settings
Figure 4: Java Settings

The Open Associated Perspective dialog indicates that the Java perspective is associated with the kind of project selected. Click Open Perspective, as shown in Figure 5.

Open Java Perspective
Figure 5: Open Java Perspective

The Java perspective may be opened at a later stage by selecting Window>Perspective>Open Perspective>Java (see Figure 6).

Window>Perspective>Open Perspective>Java
Figure 6: Window>Perspective>Open Perspective>Java

The Java perspective icon gets added, as shown in Figure 7.

Java Perspective Icon
Figure 7: Java Perspective Icon

We also need to open some Views by selecting Window>Show View, as shown in Figure 8.

Window>Show View
Figure 8: Window>Show View

Open the Package Explorer, Project Explorer, Console, and Outline Views, as shown in Figure 9. The MagazineSubscription project is also shown in in the Project Explorer View.

Package Explorer, Project Explorer, Console, and Outline Views
Figure 9: Package Explorer, Project Explorer, Console, and Outline Views

Setting Java Version and Preferences

To set or verify the Java version and preferences, select Window>Preferences, as shown in Figure 10.

Window>Preferences
Figure 10: Window>Preferences

The Java preferences settings are shown in Figure 11.

Java Preferences
Figure 11: Java Preferences

The Java Compiler settings should be set to JDK Compiler compliance level 9, as shown in Figure 12.

Compiler Compliance Level set to 9
Figure 12: Compiler Compliance Level set to 9

Creating a Java Interface

In this section, we shall create a Java interface making use of private method/s. A new Java interface may be created by selecting one of the following options:

  • Right-click the project in Project Explorer and select New>Interface, as shown in Figure 13.
  • Select File>New>Interface.
  • Select Java>Interface in New window, as listed in Figure 2, and click Next.
  • Select Interface in the New window and click Next.

Project>New>Interface
Figure 13: Project>New>Interface

Selecting any of the options starts the New Java Interface window, as shown in Figure 14. The Source folder is set to MagazineSubscription>src by default. Specify Package name (magazinesubscription) and an interface Name (MagazineSubscription), and click Finish.

New Java Interface
Figure 14: New Java Interface

A new Java interface, MagazineSubscription, gets created, as shown in Figure 15.

Java Interface MagazineSubscription
Figure 15: Java Interface MagazineSubscription

Next, add methods to the interface. We shall use an example for a magazine subscription in which the subscription code could change and the other magazine details including magazine name, magazine edition (print or digital), and magazine subscription are based on the subscription code. If we were to directly code the subscription code in the other magazine details, we would need to modify each reference to the subscription code if the subscription code were to change; this would involve several code updates. This is the kind of application the private method in the interface has been provisioned for. We shall encapsulate the common code logic in a private method, getMagazine(int subscriptioncode), which returns the magazine based on the subscription code argument supplied. Once the magazine is known, the default settings for other magazine details may be coded in separate methods. The private method getMagazine(int subscriptioncode) is listed.

private String getMagazine(int subscriptioncode) {

   if (subscriptioncode == 1)
      return "Oracle Magazine";
   else if (subscriptioncode == 2)
      return "Java Magazine";
   else
      return "Not Valid Subscription Code";

}

Next, add methods that include default implementation for getting the magazine name, magazine edition, and magazine frequency. The MagazineSubcription interface is listed:

package magazinesubscription;

public interface MagazineSubscription {

   private String getMagazine(int subscriptioncode) {

      if (subscriptioncode == 1)
         return "Oracle Magazine";
      else if (subscriptioncode == 2)
         return "Java Magazine";
      else
         return "Not Valid Subscription Code";

   }

   default String getMagazineFrequency(int subscriptioncode) {

      if (getMagazine(subscriptioncode).equals("Oracle Magazine"))
         return "Weekly";
      else if (getMagazine(subscriptioncode).equals("Java
            Magazine"))
         return "Monthly";
      else
         return "Not Valid Subscription Code";

   }

   default String getMagazineEdition(int subscriptioncode) {

      if (getMagazine(subscriptioncode).equals("Oracle Magazine"))
         return "Print only";
      else if (getMagazine(subscriptioncode).equals("Java
            Magazine"))
         return "Digital Only";
      else
         return "Not Valid Subscription Code";

   }

   default String getMagazineName(int subscriptioncode) {

      if (getMagazine(subscriptioncode).equals("Oracle Magazine"))
         return "Oracle Magazine";
      else if (getMagazine(subscriptioncode).equals("Java
            Magazine"))
         return "Java Magazine";
      else
         return "Not Valid Subscription Code";

   }

}

Copy the code to the MagazineSubscripton interface in Eclipse. To format the code, right-click in the interface and select Source>Format (see Figure 16).

Source>Format
Figure 16: Source>Format

The formatted MagazineSubscription interface is shown in Figure 17.

Formatted MagazineSubscription interface
Figure 17: Formatted MagazineSubscription interface

Conclusion

In this article, we introduced private interface methods, a new feature in Java 9. We discussed its need and created a Java project to use private interface methods. First, we created an interface that includes a private interface method. In a subsequent article, we shall implement the interface in a class to demonstrate the use of private interface methods.

Home
Mobile Site | Full Site