Interface-based applications in Java 8

What's strange about Java? Every programming language has its quirks and Java is no different. In this post, I present one of Java's oddities, which was introduced to this language in the Java 8 release.

Basing applications on interfaces

A Java application consists of at least one class that declares a main() entry-point method with the following header -- args is optional and can be replaced with another non-reserved identifier:

public static void main(String[] args)

For example, you create a simple SayHello application whose main() method outputs a hello message. The source code appears in Listing 1.

Listing 1. Class-based SayHello application

public class SayHello
{
   public static void main(String[] args)
   {
      if (args.length == 0)
         System.out.println("Hello!");
      else
         System.out.printf("Hello %s!%n", args[0]);
   }
}

Compile Listing 1 as follows:

javac SayHello.java

Run the application as follows:

java SayHello Java

You observe the following output:

Hello Java!

You also observe that the main() method must be declared in a class in order to create an application. Although that was once true, it's no longer necessary for main() to exist in a class. Check out Listing 2.

Listing 2. Interface-based SayHello application

public interface SayHello
{
   public static void main(String[] args)
   {
      if (args.length == 0)
         System.out.println("Hello!");
      else
         System.out.printf("Hello %s!%n", args[0]);
   }
}

SayHello has been transformed from a class-based application to an interface-based application by replacing class with interface. Starting with Java 8, you can compile the source code and run the application as I previously showed.

Java 8 extended interface types to also support default and static method declarations. Consequently, you can declare the main() entry-point method as an interface member, which leads to creating interface-based application types.

Don't expect an interface-based application type to be fully equivalent to a class-based application type. For example, unlike a class, you cannot instantiate an interface. As a result, you cannot declare non-static fields in an interface. Also regarding fields, you can declare only static constants in an interface: interfaces don't support static fields with mutable state.

Conclusion

It's probably best to avoid this design pattern, or perhaps anti-pattern is more appropriate. It doesn't work with Java versions earlier than Java 8. Also, it has the potential to confuse the heck out of Java beginners.

There's another potential disadvantage. Although this feature works with Oracle's reference implementation of Java 8, perhaps another vendor's Java 8 (or future) implementation might prevent an interface-based application from running.

The following software was used to develop the post's code:

• 64-bit JDK 8u60

The post's code was tested on the following platform(s):

• JVM on 64-bit Windows 8.1

This story, "Interface-based applications in Java 8" was originally published by JavaWorld.