Interfaces Funcionais Genéricas

Conceitos principais

• Expressões lambda não podem ser genéricas: Não é possível especificar parâmetros de tipo diretamente em uma expressão lambda.
• Interfaces funcionais podem ser genéricas: O tipo de destino de uma expressão lambda é determinado pelos argumentos de tipo especificados na referência da interface funcional.
• Reaproveitamento de código: Interfaces genéricas eliminam a necessidade de criar múltiplas interfaces funcionais para diferentes tipos de dados, permitindo reutilizar a lógica com tipos variados.

Exemplo prático: Interface funcional genérica SomeTest
A interface genérica SomeTest pode ser usada para implementar lambdas com diferentes tipos (por exemplo, Integer, Double, String).

Código

// 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.");
        }
    }
}
// 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.");
        }
    }
}
// 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.");
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Saída

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

Enter fullscreen mode Exit fullscreen mode

Explicação do exemplo
Definição da interface genérica:

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

Enter fullscreen mode Exit fullscreen mode

T é o tipo genérico que será substituído pelos tipos específicos (Integer, Double, String, etc.).

Uso de expressões lambda:

• A primeira lambda (isFactor) verifica se um número inteiro é divisível por outro.
• A segunda lambda (isFactorD) realiza a mesma operação, mas com números do tipo Double.
• A terceira lambda (isIn) verifica se uma string contém outra string.

Reutilização da mesma interface:
A interface SomeTest é utilizada com diferentes tipos de dados (Integer, Double, String), demonstrando a flexibilidade dos genéricos.

Benefícios das Interfaces Funcionais Genéricas

• Redução de código redundante: Uma única interface genérica substitui várias específicas.
• Flexibilidade: Adaptação a diferentes tipos de dados com o mesmo comportamento lógico.
• Compatibilidade com expressões lambda: Permite construir lambdas reutilizáveis e mais concisas.

Exercício sugerido
Refaça a interface funcional NumericFunc mencionada anteriormente como uma interface genérica. Use-a para realizar operações como calcular o quadrado de um número ou verificar se um número é par.

Exemplo Completo: Refatorando NumericFunc como Genérica

// 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)) ;
    }
}
// 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)) ;

    }
}
// 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)) ;

    }
}

Enter fullscreen mode Exit fullscreen mode

Saida:

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

Enter fullscreen mode Exit fullscreen mode

原文链接：Interfaces Funcionais Genéricas