Lambda can only be used with functional interface?

问题:

I did this:

public class LambdaConflict
{
    public static void main(String args[]){
        //*
        System.out.println(LambdaConflict.get(
            (str) -> "Hello World!! By ME?"
        ));
        /*/
        System.out.println(LambdaConflict.get(new Intf<String> (){
            @Override public String get1(String str){
                return "Hello World!! By get1 " + str;
            }
        }));
        /*****/
    }

    public static String get(Intf<String> i, boolean b){
        return i.get1("from 1");
    }
}

interface Intf<T>
{
    public T get1(T arg1);

    public T get2(T arg1);
}

and get this exception:

incompatible types: Intf is not a functional interface multiple non-overriding abstract methods found in interface Intf Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output 1 error

Is there any condition that I can't use lambda to replace anonymous class?

回答1:

No. There is no way to "overcome" this. A functional interface must have only one abstract method. Your interface has two:

interface Intf<T> {
    public T get1(T arg1);
    public T get2(T arg1);
}

Note: You don't need to annotate your interface as mentioned in comments. But you can use the @FunctionalInterface annotation to get compile time errors if your interface is not a valid functional interface. So it brings you a little bit more security in your code.

For more see e.g. http://java.dzone.com/articles/introduction-functional-1

回答2:

Just for reference and to enrich the answers already given:

As per JSR-335: Lambda Expressions for the Java Programming Language, in section Lambda Specification, Part A: Functional Interfaces it says:

A functional interface is an interface that has just one abstract method (aside from the methods of Object), and thus represents a single function contract. (In some cases, this "single" method may take the form of multiple abstract methods with override-equivalent signatures inherited from superinterfaces; in this case, the inherited methods logically represent a single method.)

So, what you need is to either provide a default implementation for one of your methods or put one of your methods in a different interface.

回答3:

Think about it:

• How should the compiler know if you want to override get1 or get2?

• If you only override get1, what will be get2's implementation? Even the code you commented out won't work because you don't implement get2...

There are reasons for this limitation...

回答4:

As stated by @Thomas-Uhrig, Functional Interfaces can only have one method.

A way to fix this, primarily because you never use public T get2(T arg1);, is to change the Intf<T> interface to:

@FunctionalInterface
interface Intf<T>
{
    public T get1(T arg1);
}