Why are interfaces in Java 8 allowed to have the main method?

Question

Why are interfaces allowed to have a main method in Java 8?

As stated in below code it works fine and produces output properly.

public interface Temp {
    public static void main(String args[]){
         System.out.println("Hello");
    }
}

Currently it is behaving like a class and I have executed interface with main method.

Why do we need this?

Answer 1

Since Java 8, static methods are allowed in interfaces.

main() is a static method.

Hence, main() is allowed in interfaces.

We don't need this, since it wasn't allowed before, and yet we survived. But since static methods, by definition, are not bound to an instance of a class, but to the class itself, it makes sense to allow them in interfaces. It allows defining utility methods related to an interface (like the ones found in Collections , for example), in the interface itself, rather than a separate class).

There is no difference between class static methods and interface static methods.

Answer 2

I second the answer of @jb-nizet. There is no "desparate need" for this, but it removes an unnecessary restriction. Eg one example is, that you can now declare a factory method within the interface:

 public interface SomeService {

   public static SomeService getInstance() {
     // e.g. resolve via service provider interface
   }

   ...

 }

Before Java 8 we needed always a separate factory class. One favorite example is the google app engine API.

Answer 3

In Java 8 an interface can have static methods. Since the main method is also a static method, it will allow it.

We can declare common helper methods using these static methods.

Answer 4

More of an addendum: maybe one thought here is to resemble what you can do with the Application trait in Scala:

object Main extends Application {
  Console.println("Hello World!")
}

simply by extending Application , you turn a class into something that runs.

Answer 5

From Brian Goetz's in the comments:

I think you have the question backwards. The question is not "should main methods be allowed", it is "should we have explicitly disallowed main methods now that static methods are permissible in interfaces" (or, equivalently, exclude interface classes as targets for the java launcher.) This would have been adding extra rules just to exclude something some people perceive as weird (but not dangerous) -- and that's a losing game. You want to define as few new rules as you can reasonably get away with -- because otherwise you get mired in complexity.

Answer 6

Personally I've always found weird the fact that I had to elect a class to be the main class (ie to host the main method), so putting the main method in an interface does not sound weird at all to me. If the main method is in an interface, I don't have to think about "what else to put in the main class" to justify its existence in an OO program. If the main class contains only the main method, it makes it look like a procedural program. If I put other members in the main class, it doesn't look cohesive at all, so...welcome main method in interfaces!