In Kotlin, default parameters are a feature that allows developers to define default values for function parameters. This means that if a function is called with fewer arguments than expected, the default values will be used instead. Default parameters can help simplify function calls and reduce the amount of code you need to write.

Defining Default Parameters

To define default parameters in Kotlin, you simply specify a default value for a parameter in the function declaration. Here’s an example:

fun sayHello(name: String = "softAai") {
    println("Hello, $name!")
}

sayHello()      // prints "Hello, softAai!"
sayHello("amol") // prints "Hello, amol!"

In this example, the sayHello function has a default parameter name with a default value of \"softAai\". When called with no arguments, the function will print \”Hello, softAai!\”. When called with an argument, such as \"amol\", the function will print \”Hello, amol!\”.

Using Default Parameters in Functions

Default parameters can be useful when writing functions that have many optional parameters or when you want to provide a default value for a parameter that is commonly used. Here’s an example of a function that uses default parameters to simplify its signature:

fun sendResumeEmail(to: String, subject: String = "", body: String = "") {
    // send email with given parameters and attached resume 
}

sendResumeEmail("[email protected]")                     // sends resume email with empty subject and body
sendResumeEmail("[email protected]", "Resume")            // sends resume email with "Resume" as subject and empty body
sendResumeEmail("[email protected]", "Resume", "PFA!")  // sends resume email with "Resume" as subject and "PFA!" as body

In this example, the sendResumeEmail function has two optional parameters, subject and body, with default values of \"\". This allows the function to be called with just a to parameter, which will send an email with an empty subject and body, or with both subject and body parameters, which will send a resume email with the specified subject and body.

Using Default Parameters with Named Parameters

Default parameters can also be used with named parameters to make the function call more readable and self-documenting. Here’s an example:

fun calculateInterest(principal: Double, rate: Double = 0.05, years: Int = 1): Double {
    val interest = principal * rate * years
    return interest
}

val interest1 = calculateInterest(principal = 1000.0, rate = 0.06, years = 2)
val interest2 = calculateInterest(principal = 500.0, rate = 0.07)
val interest3 = calculateInterest(principal = 2000.0)

println("Interest 1: $interest1") // prints "Interest 1: 120.0"
println("Interest 2: $interest2") // prints "Interest 2: 17.5"
println("Interest 3: $interest3") // prints "Interest 3: 100.0"

In this example, the calculateInterest function has three parameters, principal, rate, and years, with default values of 0.05 and 1, respectively. By using named parameters, we can specify only the parameters we care about and use the default values for the others. This makes the function call more readable and reduces the amount of boilerplate code needed.

Using Default Parameters with Extension Functions

Default parameters can also be used with extension functions in Kotlin. When defining an extension function with default parameters, you can specify default values for any optional parameters. Here’s an example:

fun String.format(separator: String = ", ", prefix: String = "[", suffix: String = "]"): String {
    return "$prefix${this.split(",").joinToString(separator)}$suffix"
}

In this example, we define an extension function on the String class called format. The format function takes three optional parameters: separator, prefix, and suffix. Each parameter has a default value, making them optional. The format function splits the string by commas and joins the resulting list with the specified separator, prefix, and suffix.

Using Default Parameters with Java Interoperability

Default parameters can also be used with Java interoperability in Kotlin. When a Kotlin function with default parameters is called from Java code, the default values are automatically generated as overloaded methods. Here’s an example:

@JvmOverloads
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

In this example, we use the @JvmOverloads annotation to tell the Kotlin compiler to generate overloaded methods for each combination of parameters, including the default parameters. This allows Java code to call the greet function with either one or two parameters, using the default value for the second parameter if it is not specified.

Using Default Parameters in Function Overloading

Default parameters can also be used in function overloading in Kotlin. When defining overloaded functions with default parameters, you can specify different default values for each function. Here’s an example:

fun multiply(x: Int, y: Int = 1) = x * y

fun multiply(x: Double, y: Double = 1.0) = x * y

In this example, we define two overloaded functions called multiply. The first function takes two integers and multiplies them together, with a default value of 1 for the second parameter. The second function takes two doubles and multiplies them together, with a default value of 1.0 for the second parameter. This allows callers to use either function with different types of parameters, while still providing default values for the optional parameters.

One more thing to note about default parameters in Kotlin is that they can only be defined for parameters that come after all non-default parameters. In other words, if a function has a mix of parameters with default and non-default values, the non-default parameters must come first in the parameter list, followed by the parameters with default values.

For example, this is a valid function with default parameters in Kotlin:

fun sayHello(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

In this example, the name parameter is a required parameter, while the greeting parameter has a default value of \”Hello\”. If we were to call the function without providing a value for greeting, the default value would be used:

sayHello("softAai") // Prints "Hello, softAai!"

However, if we were to define the function with the parameters in the opposite order, it would not be valid:

// This is not valid!
fun sayHello(greeting: String = "Hello", name: String) {
    println("$greeting, $name!")
}

This is because the greeting parameter with the default value comes before the required name parameter. Defining default parameters in this way would result in a compilation error.

So in Kotlin, when defining a function with default parameters, the parameters with default values must come after all the parameters without default values in the function declaration. If this order is not followed, the code will not compile and the Kotlin compiler will generate an error message. This is a design decision made in the Kotlin language to prevent potential errors and to ensure clarity and consistency in the way functions with default parameters are defined.

Benefits of default parameters in Kotlin:

1. Default parameters allow developers to define function parameters with default values, which can be used if a value is not provided by the caller. This can simplify function calls by reducing the number of parameters that need to be specified.
2. Default parameters can help improve code readability, as developers can define a function with fewer parameters, making it easier to read and understand.
3. Default parameters can also simplify function overloading, as developers can define multiple versions of a function with different default parameter values, reducing the need for separate functions with different parameter lists.
4. Default parameters can help improve code maintenance, as developers can change the default parameter values in a function without having to modify all the callers of that function.

Limitations of default parameters in Kotlin:

1. One of the limitations of default parameters is that they can only be defined for function parameters, not for properties or other types of variables.
2. Default parameters can also make it more difficult to understand the behavior of a function, as callers may not be aware of the default parameter values and may not explicitly provide all necessary parameters.
3. Default parameters can also lead to ambiguous function calls if there are multiple functions with similar parameter lists and default values.
4. Default parameters can also have a negative impact on performance if a function is called with default parameter values frequently, as the function may need to execute additional logic to handle the default values.

Overall, default parameters in Kotlin can provide benefits in terms of code readability, maintenance, and simplifying function calls, but they should be used carefully and with consideration for their limitations.