Réponse.

Les paramètres par défaut en Kotlin permettent de spécifier des valeurs par défaut directement dans la signature de la fonction, rendant le code plus compact et flexible. Cette possibilité améliore la lisibilité et facilite la maintenance, réduisant la nécessité de créer des méthodes surchargées avec un nombre d'arguments différent.

Historique de la question

En Java, pour différents types d'appels de fonction, il est souvent nécessaire d'écrire plusieurs méthodes surchargées. En Kotlin, une méthode concise a été développée pour déclarer des valeurs par défaut, ce qui a permis de simplifier l'API.

Problème

La surcharge de méthodes pour différents types d'appels est complexe et peu pratique, conduisant à du code excessif et à des erreurs potentielles de maintenance.

Solution

Kotlin permet de déclarer des paramètres par défaut directement dans la définition de la fonction. Cela est réalisé à travers des méthodes synthétiques de compagnons au niveau du bytecode JVM (lorsqu'il est appelé depuis Java) ou par simple passage de valeurs (depuis Kotlin). Associé aux paramètres nommés, cela rend l'interface d'appel des fonctions très puissante.

Exemple de code:

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

greet()                           // Hello, Guest!
greet("Alice")                    // Hello, Alice!
greet(greeting = "Hi")            // Hi, Guest!
greet("Bob", greeting = "Welcome") // Welcome, Bob!

Caractéristiques clés :

Les paramètres par défaut peuvent être spécifiés pour n'importe quel paramètre à droite (lors de leur utilisation depuis Java — uniquement pour les derniers).
Permet d'utiliser des paramètres nommés pour la clarté et de passer des valeurs non nécessaires.
Au niveau du bytecode pour les appels depuis Java, le compilateur génère des méthodes supplémentaires (surchargées) avec des arguments manquants.

Questions pièges.

Peut-on utiliser des paramètres par défaut dans des fonctions au sein des interfaces ?

Oui, mais la valeur par défaut est uniquement mise en œuvre lors de l'appel depuis Kotlin, et lors de l'appel de cette méthode depuis Java, il est nécessaire de spécifier explicitement les arguments.

Peut-on spécifier un paramètre par défaut pour les premiers (gauche) paramètres, et pas seulement pour les derniers ?

Oui, c'est possible en Kotlin, surtout si des arguments nommés sont utilisés lors de l'appel. Cependant, lors de l'utilisation de la fonction depuis Java, des complications peuvent survenir, car Java ne prend pas en charge les arguments nommés et les paramètres par défaut doivent se trouver à droite.

Comment fonctionne l'ordre des arguments lors de l'utilisation mixte de paramètres positionnels et nommés ?

En Kotlin, après le premier argument nommé, tous les suivants doivent être nommés, sinon une erreur de compilation se produira.

greet("Ivan", greeting = "Zdrastvuyte")      // OK
greet(greeting = "Zdrastvuyte", "Ivan")      // Erreur : impossible de passer un positionnel après un argument nommé

Erreurs typiques et anti-patterns

Utilisation d'un grand nombre de paramètres par défaut au détriment de la lisibilité (il est préférable de diviser en fonctions plus spécialisées).
Des noms de paramètres peu évidents conduisent à des erreurs (lorsque la syntaxe nommée est utilisée).
Abus d'arguments positionnels lors de signatures de fonction complexes.

Exemple de la vie réelle

Cas négatif

Dans une bibliothèque de journalisation, 10 méthodes surchargées ont été mises en œuvre pour différentes combinaisons de journalisation (avec Exception, avec Tag, sans etc.), il est peu pratique de les maintenir.

Avantages :

Chaque méthode décrit clairement une variante de journalisation.

Inconvénients :

Il est facile de commettre une erreur lors de la mise à jour/expansion d'une méthode.
Augmentation du volume de code, complexité de l'API.

Cas positif

Utilisation d'une fonction avec des arguments par défaut :

fun log(msg: String, tag: String = "", throwable: Throwable? = null) { ... }