Interfaces Funcionales

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 39 de 87.

Una interfaz funcional es una interfaz que contiene exactamente un método abstracto. Esta restricción de un solo método hace que las interfaces funcionales sean especiales porque pueden implementarse mediante expresiones lambda, lo que permite un estilo de programación más conciso.

Java proporciona la anotación @FunctionalInterface para marcar explícitamente una interfaz como funcional. Aunque es opcional, esta anotación ayuda al compilador a detectar errores si añades accidentalmente un segundo método abstracto:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Puedes implementar una interfaz funcional de la manera tradicional con una clase, o de forma más concisa con una expresión lambda:

// Implementación tradicional
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Expresión lambda (¡mucho más corta!)
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

Las interfaces funcionales aún pueden tener métodos predeterminados y métodos estáticos, ya que estos no cuentan para la regla del único método abstracto. El paquete java.util.function de Java proporciona muchas interfaces funcionales integradas, como Predicate, Function y Consumer, con las que te encontrarás frecuentemente al trabajar con streams y colecciones.

Desafío

Fácil

Construyamos un sistema de transformación de cadenas mediante interfaces funcionales y expresiones lambda. Crearás un procesador de texto flexible que puede aplicar diferentes transformaciones a las cadenas: todo impulsado por una única interfaz funcional.

Organizarás tu código en tres archivos:

StringTransformer.java: Define una interfaz funcional que represente cualquier operación de transformación de cadenas. Márcala con la anotación @FunctionalInterface para asegurarte de que siga siendo funcional. Tu interfaz debe declarar un único método abstracto llamado transform que reciba una cadena y devuelva una cadena.
TextProcessor.java: Crea una clase que utilice tu interfaz funcional para procesar texto. Debe tener un campo que contenga un StringTransformer y un constructor para inicializarlo. Incluye un método llamado process(String text) que aplique el transformador al texto proporcionado y devuelva el resultado. Este diseño te permite inyectar cualquier comportamiento de transformación mediante el constructor.
Main.java: Reúne todo creando diferentes transformaciones mediante expresiones lambda. Recibirás dos entradas: una cadena de texto y un tipo de operación (upper, lower o reverse).
Según el tipo de operación, crea un TextProcessor con la lambda adecuada:
- upper: transforma el texto a mayúsculas
- lower: transforma el texto a minúsculas
- reverse: invierte el texto (pista: usa StringBuilder)
Después, llama a process() con el texto de entrada e imprime el resultado con este formato: Result: [transformed text]

Recibirás dos entradas: el texto que se transformará (String) y el tipo de operación (String).

Observa cómo la misma clase TextProcessor puede realizar operaciones completamente diferentes dependiendo de la lambda que le pases: ¡ese es el poder de las interfaces funcionales!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String operation = scanner.nextLine();
        
        TextProcessor processor;
        
        // TODO: Basado en el tipo de operación, crea un TextProcessor con la lambda apropiada:
        // - "upper": transforma el texto a mayúsculas
        // - "lower": transforma el texto a minúsculas
        // - "reverse": invierte el texto (pista: usa StringBuilder)
        
        // TODO: Llama a process() con el texto de entrada e imprime el resultado
        // Formato de salida: "Result: [transformed text]"
    }
}