Why `private static` field is not allowed in Java 8 interface?

Question

When I\'m trying to compile the following code

public interface SomeInterface{
    private static Logger logger = Logger.getLogger();

    public default voi         


        

Answer 1

public interface SomeInterface {
    public default void someMethod() {
        SomeInterfaceInternal.logger.info("someMethod: default implementation");
    }
}

final class SomeInterfaceInternal {
    protected static final Logger logger = LoggerFactory.getLogger(SomeInterface.class);
}

Answer 2

In the pre-Java-8 view of the world, interfaces were purely for interface contracts, and private members exist purely for implementation, so this restriction was completely sensible.

In the post-Java-8 world, where interfaces can carry behavior (but not state), it starts to be reasonable to ask whether other features of classes should be applied to interfaces as well. (However, just because something might be "reasonable" doesn't mean it must be supported; there is often more than one reasonable way to construct the world.)

In Java 9, private methods in interfaces will be supported.

Answer 3

The goal of interface is to define something implemented by other classes. A private field does not define anything as it is not visible outside the interface. Hence it does not make any sense in this construct. It may be some hacks how to use it (maybe from interface inner classes) but would not look like a good design anyway.

If you actually implement part of the functionality, use abstract class instead.

Answer 4

Interfaces are not classes. They have no private state. Even a public logger in the interface is a design smell and an abuse of interfaces.

The use case for static fields in interfaces is mainly for compile-time constants, not for stateful objects.

Answer 5

Interface is like a blueprint of any class, where you declare your members. Any class that implement that interface is responsible for its definition. Private members can only be accessed by same class member, which does not make sense in terms of interface. Protected members can be accessed by same class member and inherited class members, but in case of interface we never extend an interface, we implement it. So any interface can only contain public methods generally,