fonctionnelle des interfaces de java 8 dans java 7

sont les interfaces fonctionnelles de java 8, disponible quelque part (c'est à dire un bocal) afin que je puisse les utiliser dans un Java 7 projet? de cette façon, je pouvais plus tard plus facile de port le code pour idiomatiques java 8. sinon, est-ce que cela est techniquement possible ou font-ils l'utilisation de nouvelles fonctionnalités comme les méthodes par défaut?

oui, je voulais dire les interfaces en java.util.fonction. depuis l'ajout de packages java avec préfixe semble être refusé de les importer à partir de quelque part d'autre n'est pas une option.

L'interface qui vous intéressent? Une interface qui définit une seule méthode est une interface fonctionnelle, mais le concept est pas trop utile sans les expressions lambda
En gros, c'est que le cas particulier du modèle de Stratégie où le réalisateur classes implémentent une seule méthode abstraite. Dans Java 8 c'est juste du sucre syntaxique.

OriginalL'auteur msung | 2014-04-07

  1. 16

    Une interface fonctionnelle est simplement une interface avec un seul non-par défaut, non méthode statique. Toutes les interfaces qui répondent à cette définition peuvent être mises en œuvre par le biais d'un lambda dans Java 8.

    Par exemple, Runnable est une interface fonctionnelle et en Java 8, vous pouvez écrire: Runnable r = () -> doSomething();.

    De nombreuses interfaces fonctionnelles apportées par Java 8 sont en le java.util.function le paquet. Les plus courantes sont les suivantes:

    • Consumer<T> qui a un void accept(T t)
    • Supplier<T> qui a un T get()
    • Function<T, R> qui a un R apply(T t)
    • Predicate<T> qui boolean test(T t)

    Ce que vous pourriez faire à ce stade est d'utiliser une seule méthode interfaces où il fait sens, si possible avec des signatures similaires. Lors de la migration vers Java 8, vous serez en mesure de facilement refactoriser par le biais de votre IDE à partir de:

    someMethod(new MyConsumer<T>() { public void accept(T t) { use(t); } });

    en

    someMethod(t -> use(t));

    Puis modifier la signature de someMethod(MyConsumer<T> mc) en someMethod(Consumer<T> c), se débarrasser de vous MyConsumer interface et vous avez terminé.

    Ajouter dessus, l'interface doit avoir un et un seul non-par défaut et non méthode statique. (Méthodes statiques sont également autorisés dans les interfaces fonctionnelles)
    en effet modifié.
    Depuis vos propres interfaces doivent résider dans un autre package (vous n'êtes pas autorisé à ajouter à java. …), vous pouvez même nom il Consumer plutôt que MyConsumer. Et si la signature correspond exactement, vous pouvez transformer votre propre Consumer dans une sous-interface de java.util.function.Consumer lors de la migration vers Java 8.

    OriginalL'auteur assylias

  2. 6

    Voici la signature de java 8 principales interfaces fonctionnelles comme un complément à assylias réponse

    public interface Consumer<T> {
    void accept(T t);
}

public interface Supplier<T> {
    T get();
}

public interface Function<T, R> {
    R apply(T t);
}

public interface Predicate<T> {
    boolean test(T t);
}

    OriginalL'auteur mkdev

  3. 1

    La Java 8 interfaces fonctionnelles sont limitées. Utiliser le FunctionalJava types P1, F, F2, F3, ..., F8, TryCatch0, TryCatch1, ..., TryCatch8 à faire la même chose maintenant avec plus de fonctionnalités.

    https://functionaljava.ci.cloudbees.com/job/master/javadoc/

    Vous pouvez utiliser le Rétro Lambda projet pour compiler avec Java 8 et les lambdas, mais l'objectif de la VM Java 7. Cela évite toute l'anonyme intérieur de la classe non-sens. Voir la FunctionalJava projet pour un exemple (http://www.functionaljava.org/).

    Ils sont limités pour une raison. Un générique 8-paramètres de la fonction avec 8 paramètres génériques est presque garanti à confondre celui qui opère dans le code.

    OriginalL'auteur Mark Perry

  4. 0

    En plus de la réponse par @assylias qui, je pense, permet de résoudre le problème dans la plupart des cas, il ya une option, et qui est, pour faire de votre propre @FunctionalInterface et de garder de cette façon.

    Il dépend de l'endroit où vous utilisez les fonctions. Toutes ces interfaces peuvent être utilisées par JDK classes utilitaires. Predicate permet de filtrage, Supplier permet la création d'objet, Function permet la cartographie ... En fait, Predicate et Supplier sont plutôt compliqué, mais Function et Consumer peut être souvent difficile, en particulier BiFunction. Ils peuvent également lier vos mains dans certains cas d'utilisation.

    Vous pouvez écrire votre propre interface qui dispose d'une quantité d'intrants, jette checked exceptions, a les génériques uniquement lorsque vous en avez besoin et son nom l'indique ce qu'il doit être utilisé pour.

    //@FunctionalInterface
public interface MyCustomInterface {
    <T> MyCustomOutput myCustomAction(MyCustomInput<T> str) throws MyCustomException;
}

    Ainsi, alors que les interfaces fournies avec JDK sont utiles, parfois, vous pourriez préférez garder votre propre solution, même dans Java 8, juste avec les annotations et les lambdas au lieu de anonyme classes.

    OriginalL'auteur Vlasec