Are there dangers in making an existing Java interface functional?

Question

As a rule, in the context of a large project, is it considered safe to take make an existing, ubiquitously used interface into a functional interface?

E.g., given an existing interface and class:

public interface Interface {
    public double calculateSomething(double x);
    public void doSomething();
}

which is implemented by

class InterfaceImplementer implements Interface {

     public double calculateSomething(double x) {
          return 2 * x;
     }

     public void doSomething() {
         // insert specific behavior here
     } 
}

can I safely change the interface by defining all but one method as default:

public interface Interface {
    public double calculateSomething(double x);

    default void doSomething() {
         // insert some default behavior here
    }
}

So that I can go from defining an object as

Interface object = new InterfaceImplementer() {

    @Override
    public double calculateSomething(double x) {
        return 2 * x;
    }
};

to

Interface object = (x) -> 2 * x;

while still being able to define objects in the old, tedious way.

From what I can tell, this runs no risk of upsetting any existing code, and I've made such a change to a large project and had no runtime or compile errors. But I want some confirmation whether this matches up with common knowledge and best practices.

Answer 1

Any interface that only has a single non-default method (only one method needs to be implemented in a class) is by definition a functional interface. This is a good rule!

However, a @FunctionalInterface annotation has the advantage of enforcing the "only one method in the interface for a functional interface"-rule. So if you added it to your original two-method interface, you would have gotten a compiler error. Therefore by explicitly adding @FunctionalInterface you declare your intent and make your code more clear to future maintainers.