When you write :

TestInterface i = () -> System.out.println("Hans");

You give an implementation to the void hans() method of the TestInterface.

If you could assign a lambda expression to an interface having more than one abstract method (i.e. a non functional interface), the lambda expression could only implement one of the methods, leaving the other methods unimplemented.

You can't solve it by assigning two lambda expressions having different signatures to the same variable (Just like you can't assign references of two objects to a single variable and expect that variable to refer to both objects at once).

Lambdas are implementations of "functional interfaces". A functional interface is an interface that has exactly one abstract method. The name of the method does not matter. Your original interface with only one method fulfills that condition. Your second version that has two different abstract methods does not fulfill the condition and the compiler refuses to use a lambda as an implementation of MyHandler.

Note that, if you want a very useful compiler check on the side of the interface, you can add the optional @FunctionalInterface annotation. The compiler will verify the exactly one abstract method condition:

@FunctionalInterface
interface MyHandler{
    void myFunction(int i);
}

With this annotation, it will fail to compile if the amount of abstract methods is not equal to 1.