Funktionen, Defaults & benannte Argumente

Functions in Kotlin look a little different and behave a lot more flexibly than Java methods. The fun keyword, the type-after-name order, and expression bodies trim the syntax; but the real upgrades are default parameter values and named arguments, two features that between them eliminate most method overloads and a lot of builder patterns. If you write functions all day (you do), these change your daily code.

Declaring functions

A Kotlin function uses fun, puts the return type after the parameters, and lives happily at the top level (no enclosing class required):

fun add(a: Int, b: Int): Int {       // params: name: Type; return type after the )
    return a + b
}

Two conveniences appear immediately. First, expression-body functions: when a function just returns one expression, drop the braces and return, and the return type can be inferred:

fun add(a: Int, b: Int) = a + b       // expression body; return type inferred as Int
fun greet(name: String) = "Hello, $name"

Second, a function that returns nothing has return type Unit (Kotlin's void), which you can omit:

fun log(message: String) { println(message) }   // returns Unit implicitly

Default arguments: overloads, gone

Java forces you to write overloads to allow optional parameters - the same method five times with different signatures. Kotlin gives parameters default values instead, so one function covers all the cases:

fun connect(host: String, port: Int = 8080, timeout: Int = 5000, useTls: Boolean = true) { ... }

connect("api.example.com")                       // uses all defaults
connect("api.example.com", 9090)                 // override just the port
connect("api.example.com", timeout = 10000)      // override just the timeout (see named args)

That single function replaces the four or five overloads you'd write in Java. Fewer signatures to maintain, and the defaults are visible right in the declaration instead of buried in overload chains.

Named arguments: readable calls, no builder needed

At the call site, you can pass arguments by name, in any order:

connect(host = "api.example.com", useTls = false, port = 443)   // order-independent, self-documenting

Named arguments solve two Java pain points at once:

• The boolean/positional mystery. Java's createUser("Ada", true, false, true) is unreadable - what are those booleans? Kotlin's createUser("Ada", admin = true, active = false, verified = true) is self-documenting. (Recall connascence of position from the architecture path - named arguments turn it into the weaker connascence of name.)
• The builder pattern, often. Much of the reason Java reaches for builders is to name and default a pile of optional parameters. Default + named arguments give you that readability directly, so many builders simply aren't needed in Kotlin.

Together, default values and named arguments are why Kotlin code has far fewer overloads and builders than the equivalent Java - the language does that work.