Java - Does an Interface really have no state or behavior?

Question

going through the web I always read something like

Java Interfaces have no state and no behavior

If you look what the common definition of state is then you likely end with

what the objects have, Student have a first name, last name, age, etc

The thing is I guess since Java 8 with their default methods I can also define some fields and use them as well as functions.

So I wonder if it's still valid to say that an interface in Java has no state and no behavior?

public interface DefaultInterface {

    List<Integer> numbers = new LinkedList<>();

    default List<Integer> getNumbers() {
        return numbers;
    }

    default void addId(int value) {
        numbers.add(value);
    }

    default IntStream perform(String string) {
        return string.chars();
    }

    void implementMe();
}

Answer 1

For a long time, Java interfaces could only be "pure" interfaces without default implementation, state, behavior. Default interface implementation is a fairly recent language feature. It appeared in Java 8 (2014).

The intent behind interfaces with default implementation was to allow adding methods to an interface without having to change the existing classes which implement that interface. The new methods get default implementations (while the old methods likely remain without default implementations), and the existing classes which implement the interface don't have to implement new methods.

Interfaces with default implementation could also be used like abstract classes for multiple [implementation] inheritance.

Let's look at interfaces in other languages.

• C++ doesn't have a special interface keyword. Pure interfaces (without a default implementation) are declared with class keyword and pure virtual functions.

• C# does have a special interface keyword, but no default implementation for interfaces. So, a type declared with interface can be only a pure interface without implementation.

Answer 2

One thing that may not be clear here is that this definition:

List<Integer> numbers = new LinkedList<>();

Is implicitly static and final in the context of an interface whereas it would be implicitly a member declaration in any (other) class level context. I think it would be fair to say that this is a bit confusing. This is one reason that it's a good idea to set the syntax coloring in your IDE to show static (and/or static-final) declarations as a different color, if possible.

So the state here is associated with the interface class and not instances of this. So the question "is it valid to say that an interface in Java has no state" is a little unclear. Yes, the interface class can have state but that's probably not what most people are thinking when they talk about state e.g. 'field' typically would refer to a member level reference and not a class level unless you specify 'static field'

Answer 3

With the addition of default methods, interfaces indeed have behavior. However, this may not be true for state (depending on the definition of state):

The List<Integer> numbers = new LinkedList<>(); in your interface has the implicit modifiers public static final, meaning that numbers is not a field in any implementing class, but is a "static/class constant" and not part of the state of any object that is an instance of your interface. As any state (e.g. properties and fields) is usually an implementation detail, it does not belong on the interface definition.