funzionale interfaccia Inheritance Quirk

Question

Ho un'interfaccia personalizzata che ho usato per un po 'di tempo che sembra qualcosa di simile:

public interface Function<T, R> { 
    R call(T input); 
} 

vorrei retrofit questa interfaccia sia con Java di Function così come Guava di Function , pur mantenendolo a FunctionalInterface. Pensavo di avere la perfetta organizzazione:

@FunctionalInterface 
public interface Function<T, R> extends 
     java.util.function.Function<T, R>, 
     com.google.common.base.Function<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

Entrambi superinterfacce dichiarano lo stesso apply() metodo, che è stato implementato nella mia interfaccia, lasciando solo il metodo astratto call(). Stranamente, non verrà compilato, dicendomi

Annotazione "@FunctionalInterface" non valida; Funzione < T, R > non è un'interfaccia funzionale

Peggio ancora, le seguenti variazioni compilare bene:

@FunctionalInterface 
public interface Function<T, R> extends 
     java.util.function.Function<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

@FunctionalInterface 
public interface Function<T, R> extends 
     com.google.common.base.Function<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

public interface Function<T, R> extends 
     java.util.function.Function<T, R>, 
     com.google.common.base.Function<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

@FunctionalInterface 
public interface Function<T, R> extends 
     java.util.function.Function<T, R>, 
     com.google.common.base.Function<T, R> { 

    @Override 
    R apply(T input); 
} 

C'è un motivo per cui la prima versione non verrà compilata?

Answer 1

Come indicato nei commenti, si compila bene con il compilatore oracle. È un bug di eclissi.

In attesa di una correzione di bug, personalmente io rimuovere l'annotazione @FunctionalInterface (il 3 ° variante):

public interface Function<T, R> 
           extends 
            java.util.function.Function<T, R>, 
            com.google.common.base.Function<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

Il principale inconveniente di questa soluzione è che il compilatore bug eclisse impedisce di utilizzare il Function come lambda target type .

---

Se davvero si vuole mantenere @FunctionalInterface sul Function, un (brutto) soluzione potrebbe essere quella di introdurre un interfaccia intermedia:

public interface AdapterFunction<T, R> 
             extends 
              java.util.function.Function<T, R>, 
              com.google.common.base.Function<T, R> { 
    @Override 
    default R apply(T input) { 
     return null; 
    } 
} 

e lasciate che il vostro Function estende questo AdapterFunction:

@FunctionalInterface 
public interface Function<T, R> 
           extends 
            AdapterFunction<T, R> { 

    R call(T input); 

    @Override 
    default R apply(T input) { 
     return call(input); 
    } 
} 

In questo caso, lo Function è un tipo di destinazione valido anche per eclissi :

Function<String, Object> function = st -> st.toString();