É possível implementar em Java um equivalente às…

Sim, é possível, mas não é um equivalente direto e requer soluções alternativas.

Os métodos mais comuns:

Classes utilitárias estáticas: Criar uma classe estática com métodos estáticos públicos, cujo primeiro parâmetro seja o objeto que queremos "estender".

// Classe utilitária para estender String (semelhante ao Kotlin)
public final class StringExtensions {
    // Construtor privado para evitar instâncias
    private StringExtensions() {
    }

    // "Função de extensão" para String
    public static boolean isPalindrome(String str) {
        // Verificação de palíndromo
        String reversed = new StringBuilder(str).reverse().toString();
        return str.equals(reversed);
    }
}

Uso:

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

Desvantagem: Menos legível do que em Kotlin (não há açúcar sintático na forma de objeto.metodo()).

Herança e polimorfismo: Criar uma subclasse e adicionar a funcionalidade necessária. Aplicável apenas a classes não finais.

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

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

    public int getValue() {
        return value;
    }
}

// Classe com funcionalidade "estendida"
public class ExtendedMyClass extends MyClass {
    public ExtendedMyClass(int value) {
        super(value);
    }

    // Funcionalidade adicional
    public boolean isEven() {
        return getValue() % 2 == 0;
    }
}

Desvantagem: Requer a criação de um novo tipo, não é possível "estender" instâncias existentes sem alterar seu tipo. Não funciona com classes final.

Padrão Decorador: Envolver um objeto existente em outro que fornece funcionalidade adicional.

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

// Implementação da interface
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();
    }

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

Desvantagem: Requer a criação de uma classe adicional decoradora e envolver o objeto.

Expressões lambda e interfaces funcionais (para casos específicos): Pode passar lambdas para métodos para implementar alguma lógica, mas não são funções de extensão completas.

Resumindo, em Java, não há um equivalente sintático direto às funções de extensão do Kotlin. Classes utilitárias estáticas são o método mais próximo e frequentemente usado para adicionar funcionalidade "estendida".

É possível implementar em Java um equivalente às funções de extensão, como no Kotlin?