static method in class have same signature as default method in interface

Ultimately that boils down to the fact that when you have something like this:

class Me { public static void go() { System.out.println("going"); } } 

These both would be allowed:

Me.go(); Me meAgain = new Me(); meAgain.go(); // with a warning here 

Intersting is that this would work too for example:

Me meAgain = null; meAgain.go(); 

Personally I still see this as design flaw that could not be retracted due to compatibility - but I wish the compiler would not allow me to access the static method from an instance.

Your first question is not related to java-8 per-se, it has been like this before java-8:

interface ITest { public void go(); } class Test implements ITest { public static void go() { // fails to compile } } 

default methods just follow the same rule here. Why this happens is actually detailed quite a lot on stack overflow - but the underlying idea is that potentially this would cause confusion on which method to call (imagine ITest would be a class that Test would extends and you do ITest test = new Test(); test.go(); -> which method are you calling?)

I think that for the same reasons this is not allowed also (which is basically your second question, otherwise you would have a static and non-static method with the same signatures)

static class Me { static void go() { } void go() { } } 

It's interesting that this is sort of fixed (I guess that they realized it would be really bad to do the same mistake again) in method references:

static class Mapper { static int increment(int x) { return x + 1; } int decrement(int x) { return x - 1; } } Mapper m = new Mapper(); IntStream.of(1, 2, 3).map(m::increment); // will not compile IntStream.of(1, 2, 3).map(m::decrement); // will compile 

Answering your 1st question:

Both the "static method in class" and the "default method in interface" are available to the class Main, and hence if they have the same signature, it will create ambiguity.

For example:

class C{ static void m1(){System.out.println("m1 from C");} } public class Main extends C{ public static void main(String[] args) { Main main=new Main(); main.m1(); } } 

Output: m1 from C

Similarly,

interface I{ default void m1(){System.out.println("m1 from I");} } public class Main implements I{ public static void main(String[] args) { Main main=new Main(); main.m1(); } } 

Output: m1 from I

As you can see, both these can be accessed similarly. So this is also the reason for conflict when you implement I and extend C.

Answering your second question:

If your classed and interfaces are in the same package, the default and public access modifier should work similarly.

Also, m1() in C is static which cannot be overridden, and hence it cannot be considered as implementation of m1() in I and so the compilation issue.

Hope that helps!

I will answer your first question since the second is already answered

I am aware that instance method will override the default methods but what if static methods in class have same signature as default method in Interface?

I am assuming you are using JDK 1.8 and hence the confusion. default modifier in an interface method is not talking about its access specifications. Instead it mentions that the interface itself need to implement this method. Access specification for the method is still public. Starting from JDK8 , interfaces allow you specify methods with default modifer to allow to extend interfaces in a backward compatible way.

In your interface you had to give default void m1() {} for the compilation to be successfull. Normally we simply define them in an abstract way like void m1(); in an interface You had to implement the method because you specified the method as default. Hope you understand.

Because class methods in java can also be called using instance variables, this construct will lead to ambiguities:

Main m = new Main(); m.m1(); 

It is unclear if the last statement should call the class method C.m1() or the instance method I.m1().