Kotlin - Default and Named Arguments

Default and Named Arguments in Kotlin

Kotlin is a modern, concise, and expressive programming language that offers several enhancements over Java, especially in the area of function parameters. Two of the most powerful features in Kotlin for improving function invocation are default arguments and named arguments. These features greatly increase code readability and reduce the need for function overloading.

1. Introduction to Function Parameters

Before diving into default and named arguments, let’s understand the basics of how function parameters work in Kotlin. Functions can accept parameters just like in other programming languages. Each parameter must have a name and a type.

fun greet(name: String, age: Int) {
    println("Hello, my name is $name and I am $age years old.")
}

In this example, the function greet takes two parameters: name and age. You can call this function as:

greet("Alice", 25)

2. Default Arguments in Kotlin

2.1 What Are Default Arguments?

Default arguments allow you to specify default values for function parameters. When the function is called without that parameter, the default value is used automatically.

2.2 Syntax of Default Arguments

fun greet(name: String = "Guest", age: Int = 18) {
    println("Hello, my name is $name and I am $age years old.")
}

Here, both name and age have default values. This makes the function flexible and reduces the need for multiple overloaded versions.

2.3 Calling Functions with Default Arguments

greet("Bob", 30)        // Uses both arguments provided
greet("Charlie")        // Uses provided name and default age
greet()                 // Uses both default values

2.4 Benefits of Default Arguments

• Reduces boilerplate code
• Improves readability
• Minimizes overloads
• Makes function APIs more flexible

2.5 Real-world Example

fun sendEmail(
    to: String,
    subject: String = "No Subject",
    message: String = "No Content",
    isUrgent: Boolean = false
) {
    println("To: $to")
    println("Subject: $subject")
    println("Message: $message")
    println("Urgent: $isUrgent")
}

sendEmail("admin@example.com")
sendEmail("admin@example.com", "Meeting Reminder", "Don’t forget the meeting", true)

3. Named Arguments in Kotlin

3.1 What Are Named Arguments?

Named arguments allow you to specify the name of the parameters while passing them to a function. This makes the function calls clearer, especially when dealing with many parameters or parameters with default values.

3.2 Syntax of Named Arguments

greet(name = "Daniel", age = 22)

With named arguments, the order of parameters doesn't matter:

greet(age = 22, name = "Daniel")

3.3 Mixing Named and Positional Arguments

Kotlin allows mixing named and positional arguments as long as the named arguments come after all the positional ones.

greet("Eve", age = 20)    // Valid
greet(name = "Eve", 20)   // Invalid - positional cannot follow named

3.4 When to Use Named Arguments

• When a function has many parameters
• When default values are used
• When clarity is essential

3.5 Example with Clarity

fun scheduleMeeting(
    title: String = "Weekly Sync",
    time: String = "10:00 AM",
    location: String = "Conference Room A",
    attendees: Int = 5
) {
    println("Meeting: $title at $time in $location with $attendees attendees")
}

scheduleMeeting()
scheduleMeeting(attendees = 10, title = "Client Review")

4. Combining Default and Named Arguments

These two features are even more powerful when used together. You can specify only the parameters you want using named arguments and rely on defaults for others.

fun orderPizza(size: String = "Medium", topping: String = "Cheese", crust: String = "Regular") {
    println("Order: $size pizza with $topping on $crust crust")
}

orderPizza() // All defaults
orderPizza(topping = "Pepperoni")
orderPizza(size = "Large", crust = "Thin")

4.1 Simplifies Function Usage

Instead of having 5-6 overloaded methods in Java, Kotlin’s default and named arguments offer a single, flexible interface.

5. Overloading vs Default Arguments

In Java and many other languages, overloading is used to provide multiple ways to call a method. Kotlin eliminates most of that need using default arguments.

5.1 Overloaded Example in Java

// Java-style method overloading
void greet() { greet("Guest", 18); }
void greet(String name) { greet(name, 18); }
void greet(String name, int age) { ... }

5.2 Kotlin Equivalent

fun greet(name: String = "Guest", age: Int = 18) {
    println("Hello $name, age $age")
}

This single Kotlin function replaces all the Java overloads.

6. Default Values with Nullables

You can assign null as a default value for nullable parameters.

fun showProfile(name: String, bio: String? = null) {
    println("Name: $name")
    println("Bio: ${bio ?: "No bio available"}")
}

showProfile("Alice")
showProfile("Bob", "Kotlin Developer")

7. Function Invocation from Java Code

When calling Kotlin functions with default parameters from Java, things get tricky because Java does not support default arguments. To address this, Kotlin generates multiple overloads automatically, unless the function is marked with @JvmOverloads.

7.1 Using @JvmOverloads

@JvmOverloads
fun greet(name: String = "Guest", age: Int = 18) {
    println("Hello, $name. You are $age years old.")
}

This annotation makes Kotlin generate overloads so Java code can call the function more easily.

8. Practical Use Cases

8.1 Logging

fun log(message: String, level: String = "INFO") {
    println("[$level] $message")
}

log("Starting process")
log("Critical failure", "ERROR")

8.2 UI Settings

fun configureButton(color: String = "Blue", size: String = "Medium", text: String = "OK") {
    println("Button -> Color: $color, Size: $size, Text: $text")
}

configureButton(text = "Submit")

8.3 API Requests

fun makeApiRequest(
    endpoint: String,
    method: String = "GET",
    body: String? = null,
    retries: Int = 3
) {
    println("Requesting $endpoint via $method with retries=$retries")
}

makeApiRequest("/users", retries = 1)

9. Best Practices

• Use default parameters instead of overloading.
• Use named arguments for readability, especially when calling functions with many parameters.
• Don’t mix named and positional arguments in confusing ways.
• Use @JvmOverloads if your Kotlin code is called from Java frequently.
• Only use default values when they are truly default — avoid hiding important values.

10. Summary

Kotlin’s default and named arguments offer a significant leap forward in function design and usability. With default arguments, you can avoid bloated overloads. Named arguments improve clarity and reduce ambiguity, especially for functions with many parameters or default values. These features make your code more expressive, concise, and maintainable.

Whether you're writing Kotlin for Android development, backend services, or scripting, mastering default and named arguments will make your code more elegant and easier to work with.

In conclusion, default and named arguments in Kotlin simplify function invocation by eliminating the need for multiple overloads and improving code clarity