What is the purpose of a static method in interface from Java 8?

Question

Why are static methods supported from Java 8? What is the difference between the two lines in main method in below code?

package sample;
public class A {
    public static void doSomething()
    {
        System.out.println("Make A do something!");
    }
}

public interface I {
    public static void doSomething()
    {
        System.out.println("Make I do something!");
    }
}

public class B {
    public static void main(String[] args) {
        A.doSomething(); //difference between this
        I.doSomething(); //and this
    }
}

As we can see above, I is not even implemented in B. What purpose would it serve to have a static method in an interface when we can write the same static method in another class and call it? Was it introduced for any other purpose than modularity. And by modularity, I mean the following:

public interface Singable {
    public void sing();
    public static String getDefaultScale()
    {
        return "A minor";
    }
}

Just to put like methods together.

Bal

That should explain it: docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html – Puffin

There's no difference. – Lupelupee

Static methods provide default methods that implementing classes do not to override. Its particularly useful if the the method logic is replicated across all the implementations. Your example is useful, say classes PopSong and RockSong can implement it and both would have default scale as A minor. – Idealism

@Puffin So they are used as helper methods and for modularity? How were helper methods implemented before Java 8 for the same type of functionality? – Bal

"What purpose would it serve to have a static method in an interface when we can write the same static method in another class and call it?" - well, you don't have to make a separate class now just to hold the static methods. – Everhart

@Arunav Sanyal You are confusing static and default methods. – Doodlesack

Answer 1

In the past, if you had an interface Foo and wanted to group interface-related utils or factory methods, you would need to create a separate utils class FooUtils and store everything there.

Those classes would not have anything in common other than the name, and additionally, the utils class would need to be made final and have a private constructor to forbid unwanted usage.

Now, thanks to the interface static methods, you can keep everything in one place without creating any additional classes.

It's also important to not forget all good practices and not throw everything mindlessly to one interface class - as pointed out in this answer

Cf

@GrzegorzPiwowarek Collectors, StreamSupport, Spliterators are not redundant classes at all; there has to be a line for code that is too much inside an interface. – Typography

@Typography Of course, there will always be some exceptions and this is a very good example. Putting all of this into one class would result in an unmanagable mess – Cf

Answer 2

There are mainly two reasons for static method inside interfaces: create instances of those interfaces (and the code is clearly where it has to be); like Predicate::isEqual that would create a Predicate based provided Object; or Comparator::comparing, etc. And the second reason would be utility methods that are general per all those types; like Stream::of

Still an interface has to be clear and does not have to create additional clutter in the API. Even the jdk code has Collectors - static factory methods, but a Collector interface at the same time for example. Those methods could be merged into Collector interface, but that would make the interface more clunky than it has to be.

Typography

Could you please elaborate on the create instances usage? Instead of using Stream.of, I think we may well opt for Arrays.stream to create the instance. The reason for Stream.of over Arrays.stream more or less falls back to grouping related utility methods in one namespace, which is your second use case. Or did I misinterpret your example? – Wail

@Wail what do you think Stream::of does internally? – Typography

It internally uses Arrays.stream. And that's exactly my point: you first reason ultimately falls back to your second reason. In this case, Stream.of is just a wrapper. To me, the motivation of this wrapper seems to be more "utility methods that are general per all those types" than "create instances of those interfaces". – Wail

@Wail indeed. I see your point now. I've edited the answer and thank you for the input. – Typography

I see your point now as well. Thanks for the nice example. – Wail

Answer 3

The reason is that we can call the static method by interface name and that static method can call the default method internally. Example: Comparator::comparing, so here comparing is calling the default functionalities.

Gravely

No need to repeat the question, Ashish. Try and create as formal an answer as possible, things like "ex : " are not preferred on SO. An edit has been made and will be approved soon, so no need to change the text now. – Tratner

How does a static method call a default method? Can you give an example? Because otherwise this seems unclear. – Sapanwood