How would you write an extension in Java?

Java does not have native support for extension functions like Kotlin. However, their behavior can be mimicked using the following techniques:

• Static methods in utility classes: Create a class with static methods that accept the object to be "extended" as the first argument.

  public class StringExtensions {
      // Mimicking extension function toInt() for String
      public static int toInt(String s) {
          try {
              return Integer.parseInt(s);
          } catch (NumberFormatException e) {
              return 0; // or throw a custom exception
          }
      }
  }
  

  Usage:

  String myString = "123";
  int number = StringExtensions.toInt(myString);
  

• Subclasses or inheritance: Create a new class that extends the class to be extended, and add new methods to it. This approach is suitable if you can modify the class hierarchy.

  public class ExtendedString extends String {
      // Cannot directly inherit from final class String
      // This approach does not work for final classes like String
  }
  

  For non-final classes:

  public class ExtendedArrayList<T> extends ArrayList<T> {
      // Add a new method
      public void printAll() {
          for (T item : this) {
              System.out.println(item);
          }
      }
  }
  

  Usage:

  ExtendedArrayList<String> list = new ExtendedArrayList<>();
  list.add("one");
  list.add("two");
  list.printAll(); // Using "extension" method
  

• Decorator pattern: Wrap an existing object in a new class (decorator) that provides additional methods.

  public class StringWithExtensions {
      private final String originalString;
  
      public StringWithExtensions(String originalString) {
          this.originalString = originalString;
      }
  
      // Mimicking extension function toInt()
      public int toInt() {
          try {
              return Integer.parseInt(originalString);
          } catch (NumberFormatException e) {
              return 0;
          }
      }
  
      // Access to original methods
      public String substring(int beginIndex) {
          return originalString.substring(beginIndex);
      }
  }
  

  Usage:

  String myString = "456";
  StringWithExtensions decoratedString = new StringWithExtensions(myString);
  int number = decoratedString.toInt(); // Using "extension" method
  

Each of these approaches has its advantages and disadvantages, and the choice depends on the specific situation and project constraints in Java. The most common method of mimicking is using static utility classes due to their simplicity and the ability to "extend" final classes.