Kotlin, a statically typed programming language developed by JetBrains, is known for its expressive syntax and modern language features. Two of these features, default arguments and named arguments, significantly enhance the readability and maintainability of Kotlin code. This article explores these features in depth, demonstrating their benefits and practical uses.
I have to say, I miss this feature in Java. It’s a very nice feature in Kotlin, especially when you need to fill in only some arguments of a function or data class. While you can achieve this in Java through method overriding or by using the builder pattern, as shown in the example below, it’s not as straightforward.
public class Greeter {
public void greet() {
greet("Guest", "Hello");
}
public void greet(String name) {
greet(name, "Hello");
}
public void greet(String name, String greeting) {
System.out.println(greeting + ", " + name + "!");
}
public static void main(String[] args) {
Greeter greeter = new Greeter();
greeter.greet(); // Output: Hello, Guest!
greeter.greet("Alice"); // Output: Hello, Alice!
greeter.greet("Bob", "Hi"); // Output: Hi, Bob!
}
}Java does not support named arguments directly, but you can use the Builder pattern to achieve similar functionality, especially for functions with many parameters.
public class CoffeeOrder {
private final String size;
private final int sugar;
private final boolean milk;
private CoffeeOrder(Builder builder) {
this.size = builder.size;
this.sugar = builder.sugar;
this.milk = builder.milk;
}
public static class Builder {
private String size = "Medium"; // Default value
private int sugar = 1; // Default value
private boolean milk = true; // Default value
public Builder size(String size) {
this.size = size;
return this;
}
public Builder sugar(int sugar) {
this.sugar = sugar;
return this;
}
public Builder milk(boolean milk) {
this.milk = milk;
return this;
}
public CoffeeOrder build() {
return new CoffeeOrder(this);
}
}
@Override
public String toString() {
return "Order: " + size + " coffee with " + sugar + " sugar(s) and " + (milk ? "milk" : "no milk");
}
public static void main(String[] args) {
CoffeeOrder order1 = new CoffeeOrder.Builder().build();
CoffeeOrder order2 = new CoffeeOrder.Builder().size("Large").sugar(2).milk(false).build();
CoffeeOrder order3 = new CoffeeOrder.Builder().sugar(3).build();
System.out.println(order1); // Output: Order: Medium coffee with 1 sugar(s) and milk
System.out.println(order2); // Output: Order: Large coffee with 2 sugar(s) and no milk
System.out.println(order3); // Output: Order: Medium coffee with 3 sugar(s) and milk
}
}As you can see, we have some approaches to achieve this in Java, but these options are quite verbose. Now, we are going to show you how you can work with default arguments and named arguments in Kotlin.
Default Arguments
In Kotlin, functions can have parameters with default values. This allows you to call a function without providing arguments for all parameters, reducing the need for multiple overloaded methods.
Defining Default Arguments
You can specify default values for function parameters directly in the function definition. Here’s an example:
fun greet(name: String = "Guest", greeting: String = "Hello") {
println("$greeting, $name!")
}
greet() // Output: Hello, Guest!
greet("Alice") // Output: Hello, Alice!
greet("Bob", "Hi") // Output: Hi, Bob!In this greet function, both name and greeting parameters have default values. If you call greet() without arguments, it will use the default values:
Named Arguments
Named arguments improve code clarity by explicitly specifying which argument corresponds to which parameter. This is particularly useful when a function has many parameters or parameters with the same type.
Using Named Arguments
To use named arguments, you simply specify the parameter name followed by the argument value when calling the function. Here’s an example:
fun orderCoffee(size: String = "Medium", sugar: Int = 1, milk: Boolean = true) {
println("Order: $size coffee with $sugar sugar(s) and ${if (milk) "milk" else "no milk"}")
}
orderCoffee(size = "Large", sugar = 2, milk = false) // Output: Order: Large coffee with 2 sugar(s) and no milk
orderCoffee(sugar = 3) // Output: Benefits of Default and Named Arguments
- Improved Readability: By naming arguments and providing default values, the code becomes more self-documenting and easier to understand.
- Reduced Overload Methods: Default arguments eliminate the need for multiple overloaded functions, simplifying the codebase.
- Error Prevention: Named arguments prevent errors related to the order of parameters, especially when dealing with multiple parameters of the same type.
- Flexibility: Combining default and named arguments offers great flexibility in how functions are called, allowing developers to provide only the necessary information.
Real life example
We use named arguments especially when a data class or service class has more than two arguments because it improves readability. As you can see in the example below, there are some nullable parameters that need to be initialized. If you don’t have a value for these parameters, you can either use null or provide a default value.
data class Order(
val id: UUID,
val amount: Double,
val currency: String,
val itemId: UUID,
val quantity: Int = 1,
val discount: Double?,
val shipping: Double,
val tax: Double?
)
val order1 = Order(
id = UUID.randomUUID(),
amount = 100.0,
currency = "USD",
itemId = UUID.randomUUID(),
discount = null,
shipping = 5.0,
tax = null
)
Conclusion
Kotlin’s default and named arguments are powerful features that enhance the language’s expressiveness and ease of use. By leveraging these features, developers can write more readable, maintainable, and error-resistant code. Whether you’re simplifying function calls with default values or making them clearer with named arguments, these tools are invaluable for modern Kotlin programming.
