Можно ли в Java реализовать аналог функций расширения, как в Kotlin?

Да, можно, но это не прямой аналог и требует обходных путей.

Наиболее распространенные способы:

1. Статические утилитарные классы: Создать статический класс с публичными статическими методами, первым параметром которых является объект, который мы "расширяем".

   // Утилитарный класс для расширения String (аналог Kotlin)
   public final class StringExtensions {
       // Приватный конструктор для предотвращения создания экземпляров
       private StringExtensions() {
       }
   
       // "Функция расширения" для String
       public static boolean isPalindrome(String str) {
           // Проверка на палиндром
           String reversed = new StringBuilder(str).reverse().toString();
           return str.equals(reversed);
       }
   }
   

   Использование:

   // Использование статического утилитарного метода
   String myString = "madam";
   boolean isPal = StringExtensions.isPalindrome(myString);
   

   Недостаток: Менее читаемо, чем в Kotlin (нет синтаксического сахара в виде объект.метод()).

2. Наследование и полиморфизм: Создать подкласс и добавить в него нужную функциональность. Применимо только для не final классов.

   // Оригинальный класс
   public class MyClass {
       private int value;
   
       public MyClass(int value) {
           this.value = value;
       }
   
       public int getValue() {
           return value;
       }
   }
   
   // Класс с "расширенной" функциональностью
   public class ExtendedMyClass extends MyClass {
       public ExtendedMyClass(int value) {
           super(value);
       }
   
       // Добавленная функциональность
       public boolean isEven() {
           return getValue() % 2 == 0;
       }
   }
   

   Недостаток: Требует создания нового типа, нельзя "расширить" существующие экземпляры без изменения их типа. Не работает для final классов.

3. Паттерн Декоратор: Обернуть существующий объект в другой объект, который предоставляет дополнительную функциональность.

   // Интерфейс
   public interface MyInterface {
       int getValue();
   }
   
   // Реализация интерфейса
   public class MyObject implements MyInterface {
       private int value;
   
       public MyObject(int value) {
           this.value = value;
       }
   
       @Override
       public int getValue() {
           return value;
       }
   }
   
   // Декоратор
   public class MyObjectDecorator implements MyInterface {
       private MyInterface decoratedObject;
   
       public MyObjectDecorator(MyInterface decoratedObject) {
           this.decoratedObject = decoratedObject;
       }
   
       @Override
       public int getValue() {
           return decoratedObject.getValue();
       }
   
       // Добавленная функциональность
       public boolean isOdd() {
           return decoratedObject.getValue() % 2 != 0;
       }
   }
   

   Недостаток: Требуется создание дополнительного класса-декоратора и обертывание объекта.

4. Лямбда-выражения и функциональные интерфейсы (для определенных случаев): Можно передавать лямбды в методы, чтобы реализовать некоторую логику, но это не полноценные функции расширения.

В итоге, в Java нет прямого синтаксического аналога функций расширения Kotlin. Статические утилитарные классы являются наиболее похожим и часто используемым методом для добавления "расширяющей" функциональности в Java.