¿Se puede implementar en Java un equivalente a las…

Sí, es posible, pero no es un equivalente directo y requiere soluciones alternativas.

Los métodos más comunes:

Clases utilitarias estáticas: Crear una clase estática con métodos estáticos públicos, cuyo primer parámetro sea el objeto que queremos "extender".

// Clase utilitaria para extender String (similar a Kotlin)
public final class StringExtensions {
    // Constructor privado para evitar instanciaciones
    private StringExtensions() {
    }

    // "Función de extensión" para String
    public static boolean isPalindrome(String str) {
        // Verificación de palíndromo
        String reversed = new StringBuilder(str).reverse().toString();
        return str.equals(reversed);
    }
}

Uso:

// Uso del método utilitario estático
String myString = "madam";
boolean isPal = StringExtensions.isPalindrome(myString);

Desventaja: Menos legible que en Kotlin (no tiene azúcar sintáctico en forma de obj.method()).

Herencia y polimorfismo: Crear una subclase y agregarle la funcionalidad necesaria. Solo aplicable a clases no finales.

// Clase original
public class MyClass {
    private int value;

    public MyClass(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

// Clase con funcionalidad "extendida"
public class ExtendedMyClass extends MyClass {
    public ExtendedMyClass(int value) {
        super(value);
    }

    // Funcionalidad añadida
    public boolean isEven() {
        return getValue() % 2 == 0;
    }
}

Desventaja: Requiere crear un nuevo tipo, no se puede "extender" instancias existentes sin cambiar su tipo. No funciona con clases final.

Patrón Decorador: Envolver un objeto existente en otro que proporciona funcionalidad adicional.

// Interfaz
public interface MyInterface {
    int getValue();
}

// Implementación de la interfaz
public class MyObject implements MyInterface {
    private int value;

    public MyObject(int value) {
        this.value = value;
    }

    @Override
    public int getValue() {
        return value;
    }
}

// Decorador
public class MyObjectDecorator implements MyInterface {
    private MyInterface decoratedObject;

    public MyObjectDecorator(MyInterface decoratedObject) {
        this.decoratedObject = decoratedObject;
    }

    @Override
    public int getValue() {
        return decoratedObject.getValue();
    }

    // Funcionalidad adicional
    public boolean isOdd() {
        return decoratedObject.getValue() % 2 != 0;
    }
}

Desventaja: Requiere crear una clase adicional decoradora y envolver el objeto.

Expresiones lambda e interfaces funcionales (para casos específicos): Se pueden pasar lambdas a métodos para implementar cierta lógica, pero no son funciones de extensión completas.

En resumen, en Java no existe un equivalente sintáctico directo a las funciones de extensión de Kotlin. Las clases utilitarias estáticas son el método más parecido y comúnmente usado para agregar funcionalidad "extendida" en Java.

¿Se puede implementar en Java un equivalente a las funciones de extensión, como en Kotlin?