Kotlin Extension Functions

Introduction

When we first came across extension functions, we weren’t quite sure where and how we could use it. But after a more detailed examination, we really grew fond of them. They are features that can be used exactly where they are needed. For example, we can use them when we are missing a certain function in a given class, or use them as a converter, also known as a mapper.

Kotlin extension functions are a unique feature of the Kotlin programming language. They allow you to “extend” an existing class with new functionality without having to inherit from the class. This is particularly useful when you want to add some specific utility methods to a class that you don’t own, like a Java or Kotlin standard library class, or when subclassing is not feasible or desirable.

How Extension Functions Work

• Definition: Extension functions are defined outside the class they extend. They are declared with a receiver type, which specifies the class they extend.
• Scope: They are accessible like regular methods within the scope they are defined.
• Static Nature: Under the hood, extension functions are static methods that accept the receiver object as an argument.

Advantages of Extension Functions

1. Enhanced Readability: They can make your code more concise and readable.
2. No Need for Inheritance or Decorators: Useful for adding functionality to a class without modifying it or creating a subclass.
3. Avoid Utility Classes: Reduces the need for utility classes full of static methods.
4. Context-Specific Functionality: They can be defined in a specific context, making the codebase cleaner and more maintainable.

Example: Extending the String Class

Let’s create an extension function for the String class that reverses the string and capitalizes it.

Step 1: Defining the Extension Function

fun String.reverseAndUppercase(): String {
return this.reversed().uppercase()
}

• String: The receiver type, indicating that this extension function is for the String class.
• this: Refers to the instance of the String on which the function is called.
• The function reverses the string (using the standard reversed() function) and then upper case it (using uppercase()).

Step 2: Defining the Extension Function

fun Customer.toDto(): CustomerDto {
    return CustomerDto(
        id = this.id,
        firstName = this.firstName,
        lastName = this.lastName,
        userName = this.userName.reverseAndUppercase(),
        email = this.email,
        address = this.address.toDto()
    )
}

• extension function in Kotlin, designed to convert an object of the Customer class into a CustomerDto object. The function, toDto(), is defined for the Customer class, implying that it can be called on any instance of this class. The function does not take any parameters and returns a new instance of CustomerDto.

Inside the function, a new CustomerDto object is created and returned. The properties of the new CustomerDto object are set using the properties of the Customer object on which the function is called (this). These properties include id, firstName, lastName, email, and address. The userName property is set after applying a custom method reverseAndUppercase() to it, which is presumably a method that reverses the string and converts it to uppercase. The address property is also converted to its DTO representation using a toDto() method, suggesting that the address property is itself an object that needs conversion.

This example illustrates how Kotlin’s extension functions can be used to add useful behaviors to existing classes in a clean and idiomatic way. This feature enhances Kotlin’s expressiveness and flexibility, allowing developers to write more intuitive and maintainable code.

For more information, we are including a GitHub link.