Réponse.

Dans Kotlin, les fonctions sont déclarées de manière très concise, ce qui est l'un des points forts du langage. Historiquement, en Java, les fonctions sont étroitement liées aux classes (méthodes), ne supportent pas les paramètres nommés ni les paramètres par défaut, ce qui nécessite souvent de créer des méthodes surchargées. En Kotlin, les fonctions peuvent être déclarées au niveau supérieur (top-level), et leurs paramètres sont beaucoup plus flexibles.

Problème en Java : pour différentes combinaisons d'arguments, il faut souvent créer des surcharges distinctes. Cela entraîne un code excessif et complique la maintenance.

Solution en Kotlin :

support des paramètres par défaut,
paramètres nommés,
déclaration de fonctions en dehors des classes.

Exemple de code :

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

greet() // Hello, User!
greet("Alex") // Hello, Alex!
greet(greeting = "Hi", name = "Olga") // Hi, Olga!

Caractéristiques clés :

Les paramètres par défaut réduisent le nombre de surcharges et améliorent la lisibilité.
Les paramètres nommés augmentent l'expressivité du code et préviennent les erreurs lors des longues listes d'arguments.
La déclaration libre de fonctions (top-level) simplifie l'organisation du code.

Questions pièges.

Les arguments par défaut font-ils partie de la signature de la fonction dans le bytecode ?

Non, Kotlin compile des méthodes de surcharge synthétiques séparées pour assurer la compatibilité avec Java, mais la signature de la fonction ne change pas au niveau de la JVM.

Que se passe-t-il si l'ordre des arguments nommés et positionnels est inversé ?

Les arguments positionnels doivent venir avant les nommés, sinon une erreur de compilation se produira.

Exemple d'utilisation incorrecte :

greet(greeting = "Hey", "Ivan") // Erreur de compilation

Peut-on déclarer des fonctions en dehors des classes en Java comme en Kotlin ?

Non, en Java, chaque fonction doit obligatoirement être une méthode d'une classe. En Kotlin, les fonctions de niveau supérieur sont autorisées — cela rend le code plus propre et plus testable.

Erreurs typiques et anti-patterns

Essayer de mélanger des paramètres nommés et positionnels dans un ordre incorrect.
Attendre que le code Java supporte les arguments par défaut de Kotlin — il faut manuellement créer des surcharges en Java ou utiliser @JvmOverloads.
Utilisation injustifiée d'un grand nombre de paramètres, ce qui réduit la lisibilité.

Exemple de la vie réelle

Cas négatif

Dans un grand projet Android, un développeur a implémenté des méthodes de l'API client avec 5-6 arguments positionnels et des surcharges, ce qui a conduit à des erreurs fréquentes lors des appels et à de grands blocs de code dupliqués.

Avantages :

Compatibilité avec le code Java

Inconvénients :

Complexité de maintenance
Beaucoup de code
Forte probabilité d'erreurs

Cas positif

L'utilisation de fonctions avec des paramètres par défaut et des paramètres nommés a permis d'obtenir une signature compacte, d'éliminer le besoin de surcharges, de réduire le risque d'erreurs et d'améliorer la facilité de maintenance de l'API.