¿Cómo especificar valores predeterminados en las funciones de Kotlin?

En Kotlin, puede proporcionar valores predeterminados a los parámetros en una definición de función. Si se llama a la función con argumentos pasados, esos argumentos se usan como parámetros. Sin embargo, si se llama a la función sin pasar argumentos, se utilizan los argumentos predeterminados. Pero si vienes del mundo de Java, quizás recuerdes que no podemos especificar un valor predeterminado para los métodos. Esto significa que no podemos hacer algo como esto en Java:

public void foo(int a, int b=10) {
}

Necesitamos escribir dos métodos para ello, y se conoce como sobrecarga de métodos:

public void foo(int al {
}

public void foo(int a, int b) {
}

Además, suponga que tiene una función con tres tipos diferentes de parámetros, como estos:

public void foo (int a, double b, String c){
}

Entonces tendrás siete instancias de sobrecarga de métodos:

public void foo (int a, double b, String c),
public void foo (int a, double b) ,
public void foo (double b, String c) ,
public void foo (int a, String c) ,
public void foo (int a) ,
public void foo (double b) ,
public void foo (String c)

Kotlin le proporciona valores predeterminados en los métodos mediante los cuales puede evitar una cantidad increíble de sobrecarga de métodos. Algunas personas podrían decir: «Oye, ¿por qué no usamos el patrón de construcción en lugar de la sobrecarga de métodos?». Esas personas tienen razón, pero el camino de Kotlin es más fácil que eso. ¡Veamos cómo!

Ejemplo

En Kotlin, los parámetros de las funciones pueden tener valores predeterminados y se usan cuando se omite el argumento correspondiente. Esto, a su vez, reduce el número de sobrecargas. El ejemplo anterior con tres tipos diferentes de parámetros se puede resolver fácilmente en Kotlin con mucho menos código. Agreguemos el código mencionado en el editor, ejecútelo y verifique el resultado:

fun main (args: Array<String>){
  foo ()
  foo (1)
  foo (1, 0.1)
  foo (1, 0.1, "custom string")
}
  fun foo (a: Int=0, b: Double =0.0, c:String="some default value") {
    printin ("a=$a ,b=$b ,c = Sc")
}

Si ejecuta el código anterior, verá el siguiente resultado:

Producción:

a-0 , b-0.0 ,c - some default value
a=1 , b=0.0 ,c = some default value
a=1 , b=0.1 ,c = some default value
a=1 , b=0.1 ,c = custom string

Como puede ver, no tuvimos que implementar cuatro métodos diferentes y pudimos mapear los argumentos. Los parámetros predeterminados se usan cuando no llamamos a los métodos proporcionando parámetros explícitos, por lo que cuando no pasa ningún parámetro, solo usa todos los predeterminados. Con la ayuda de argumentos con nombre, podemos reducir aún más la cantidad de métodos, pero lo cubriremos en la próxima receta. Una cosa a tener en cuenta es que los argumentos predeterminados también funcionarán con los constructores. Entonces puedes tener una declaración de clase de la siguiente manera:

data class Event (var eventName: String? - "", var eventSchedule: 
Date? - Date () , var isPrivate: Boolean - false)

Entonces podemos declarar objetos, como se muestra:

Event ("Celebration" )
Event ("Ceberation", Date () )
Event ("Ceberation", Date () , true)

Como puede ver, con la ayuda de los valores predeterminados en los constructores, evitamos la necesidad de implementar múltiples constructores, lo que solíamos hacer en Java. Recuerde que hay una trampa aquí. No podremos hacer esto si está creando objetos en Java. Esto significa que Java no aceptará hacer las cosas como se muestra en el siguiente código. Ahora sé que estarás como «¿Qué pasó con el 100% de interoperabilidad con Java?»:

new Event ("Celebration")
new Event ("Celebration", Date () )
new Event ("Celebration", Date () , true)

Solo necesitamos hacer una pequeña modificación si queremos exponer múltiples sobrecargas a las personas que llaman Java, es decir, agregar @JvmOverloads a los constructores y con valores predeterminados para que la declaración de clase anterior se convierta en esto:

data class Event @JvmOverloads constructor (var eventName: String? 
= "", var date: Date? - Date (), var isPrivate; Boolean = false)

Además, nuestro método se convierte en esto:

@JvmOverloads fun foo (a: Int=0, b: Double =0.0, c: String="some default value" ) {
printin ("a=$a , b=$b ,c = $c")

Este es un pequeño precio a pagar, pero la anotación @JvmOverloads ayuda a nuestros constructores y funciones a tener valores predeterminados, llamados desde el mundo de Java también.

Si queremos que nuestro código funcione solo en el mundo de Kotlin, entonces no necesitamos la anotación @JvmOverloads porque Kotlin tiene sus propias reglas mediante las cuales puede funcionar con valores predeterminados en constructores y funciones. Agregar la anotación @JvmOverloads crea todas las sobrecargas necesarias. Entonces, si descompila su código de bytes de Kotlin, verá todas las versiones sobrecargadas de constructores y funciones.