Interfaces fonctionnelles génériques

Concepts principaux

• Les expressions lambda ne peuvent pas être génériques : Vous ne pouvez pas spécifier de paramètres de type directement dans une expression lambda.
• Les interfaces fonctionnelles peuvent être génériques : Le type cible d'une expression lambda est déterminé par les arguments de type spécifiés dans la référence de l'interface fonctionnelle.
• Réutilisation du code : Les interfaces génériques éliminent le besoin de créer plusieurs interfaces fonctionnelles pour différents types de données, vous permettant de réutiliser la logique avec différents types.

Exemple pratique : Interface fonctionnelle générique SomeTest
L'interface générique SomeTest peut être utilisée pour implémenter des lambdas avec différents types (par exemple Integer, Double, String).

Code

// Interface funcional genérica com dois parâmetros que retorna um boolean
interface SomeTest<T> {
    boolean test(T n, T m);
}

public class GenericFunctionalInterfaceDemo {
    public static void main(String[] args) {
        // Expressão lambda para verificar se um inteiro é fator de outro
        SomeTest<Integer> isFactor = (n, d) -> (n % d) == 0;
        if (isFactor.test(10, 2)) {
            System.out.println("2 is a factor of 10");
        }

        // Expressão lambda para verificar se um Double é fator de outro
        SomeTest<Double> isFactorD = (n, d) -> (n % d) == 0;
        if (isFactorD.test(212.0, 4.0)) {
            System.out.println("4.0 is a factor of 212.0");
        }

        // Expressão lambda para verificar se uma string faz parte de outra
        SomeTest<String> isIn = (a, b) -> a.indexOf(b) != -1;
        String str = "Generic Functional Interface";
        System.out.println("Testing string: " + str);
        if (isIn.test(str, "face")) {
            System.out.println("'face' is found.");
        } else {
            System.out.println("'face' not found.");
        }
    }
}

Sortie

2 is a factor of 10
4.0 is a factor of 212.0
Testing string: Generic Functional Interface
'face' is found.

Explication de l'exemple
Définition de l'interface générique :

interface SomeTest<T> {
    boolean test(T n, T m);
}

T est le type générique qui sera remplacé par des types spécifiques (Integer, Double, String, etc.).

Utilisation des expressions lambda :

• Le premier lambda (isFactor) vérifie si un entier est divisible par un autre.
• Le deuxième lambda (isFactorD) effectue la même opération, mais avec des nombres de type Double.
• Le troisième lambda (isIn) vérifie si une chaîne contient une autre chaîne.

Réutilisation de la même interface :
L'interface SomeTest est utilisée avec différents types de données (Integer, Double, String), démontrant la flexibilité des génériques.

Avantages des interfaces fonctionnelles génériques

• Réduction du code redondant : Une seule interface générique remplace plusieurs spécifiques.
• Flexibilité : Adaptation à différents types de données avec le même comportement logique.
• Compatibilité avec les expressions lambda : Vous permet de créer des lambdas réutilisables et plus concises.

Exercice suggéré
Repensez l'interface fonctionnelle NumericFunc mentionnée précédemment en tant qu'interface générique. Utilisez-le pour effectuer des opérations telles que calculer le carré d'un nombre ou vérifier si un nombre est pair.

Exemple complet : refactoriser NumericFunc en tant que générique

// Interface funcional genérica com um parâmetro e um retorno
interface NumericFunc<T> {
    T apply(T n);
}

public class GenericNumericFuncDemo {
    public static void main(String[] args) {
        // Lambda para calcular o quadrado de um número inteiro
        NumericFunc<Integer> square = (n) -> n * n;
        System.out.println("Quadrado de 5: " + square.apply(5)); // Saída: 25

        // Lambda para calcular o quadrado de um número Double
        NumericFunc<Double> squareDouble = (n) -> n * n;
        System.out.println("Quadrado de 3.14: " + squareDouble.apply(3.14)); // Saída: 9.8596

        // Lambda para verificar se um número é par (retorna "Par" ou "Ímpar")
        NumericFunc<Integer> isEven = (n) -> (n % 2 == 0) ? n  :  -1;
        System.out.println("Resultado Numero pares de : Resultado com multiplos valores "  + isEven.apply(15)) ;

    }
}

Sortie :

Quadrado de 5: 25
Quadrado de 3.14: 9.8596
Resultado Número pares de : Resultado com múltiplos valores -1

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!