skip to content

How do named arguments combine with default arguments to let callers skip parameters, and what's the alternative in Java interop?

level: middleimportance: should knowfreq 55%

answer

  1. defaults drop trailing; names drop middle
  2. name the later param to skip an earlier default
  3. Java can't use Kotlin named/default args
  4. @JvmOverloads generates trailing overloads
  5. replaces telescoping overloads in Kotlin

basics

~20 s

When a function has default values, you can leave out a middle parameter by naming the later ones you want to set. Without named arguments you'd have to repeat every value up to the last one you care about.

solid answer

~40 s

Default arguments let a parameter be omitted; named arguments make it practical to omit one in the middle of the list. To pass a later parameter while skipping an earlier defaulted one, you name the later parameter so the compiler knows which slot it fills. Without names you could only omit trailing parameters. This is a Kotlin-only mechanic: Java callers cannot pass Kotlin named or default arguments. To make a Kotlin function with defaults callable conveniently from Java, annotate it with @JvmOverloads, which generates overloads for each default; otherwise Java must supply every argument. Inside Kotlin, prefer named arguments over telescoping overloads.

code

kotlin · 10 lines
kotlin
@JvmOverloads
fun render(text: String, bold: Boolean = false, italic: Boolean = false, size: Int = 12) {}

// Kotlin: skip the middle defaults, set only size
render("hi", size = 18)

// Java sees overloads (trailing only):
//   render("hi");
//   render("hi", true);
//   render("hi", true, true, 18);

go deeper

for a junior

Can show naming a later parameter to skip an earlier defaulted one.

for a middle

Explains defaults-drop-trailing vs names-drop-middle and that Java can't use either feature directly.

for a senior

Adds @JvmOverloads semantics (trailing overloads only) and frames the pattern against telescoping overloads.

for a principal

Designs Kotlin APIs that stay ergonomic from both Kotlin and Java, weighing @JvmOverloads cost vs. explicit overloads.

## Defaults alone only let you drop trailing parameters ```kotlin fun render(text: String, bold: Boolean = false, italic: Boolean = false, size: Int = 12) {} render("hi") // drop all trailing defaults render("hi", true) // sets bold positionally // render("hi", , , 18) // can't leave gaps positionally ``` To set only `size` while leaving `bold`/`italic` defaulted, position alone can't express the gap. ## Named arguments fill the gap ```kotlin render("hi", size = 18) // skip bold & italic, set size render("hi", italic = true, size = 16) ``` Naming the parameter you care about lets the compiler bind it to the right slot while the rest fall back to their **default values**. This is the idiomatic Kotlin alternative to the Java "telescoping constructor/overload" pattern. ## Java interop: named and default arguments don't cross the boundary Kotlin's named and default arguments are a **compile-time, Kotlin-side** feature. The JVM has no notion of them, so: - A Java caller of a Kotlin function with defaults must pass **every** parameter — it cannot omit defaulted ones or use names. - To give Java ergonomic overloads, annotate the Kotlin function with **`@JvmOverloads`**. The compiler then generates an overload for each prefix of the parameter list (dropping trailing defaulted parameters), so Java can call shorter forms. ```kotlin @JvmOverloads fun render(text: String, bold: Boolean = false, italic: Boolean = false, size: Int = 12) {} // Generates: render(String), render(String, boolean), render(String, boolean, boolean), // render(String, boolean, boolean, int) for Java. ``` Note `@JvmOverloads` only generates **trailing-omission** overloads; Java still cannot skip a middle parameter the way Kotlin's named arguments can. ## Takeaways - Inside Kotlin: defaults + named arguments replace overload explosion. - Across the Java boundary: defaults/names vanish; use `@JvmOverloads` for usable Java APIs.

  • Can a Java caller skip a Kotlin parameter that has a default value?
    Not by default — Java must pass all parameters. @JvmOverloads can generate trailing-omission overloads, but Java still cannot skip a middle parameter like Kotlin's named arguments allow.
  • What Kotlin anti-pattern do named + default arguments replace?
    Telescoping overloads/constructors, where you write many overloads differing only by which trailing parameters are supplied.

saying these in an interview costs you the question

  • Claiming Java callers can use Kotlin named arguments
  • Saying @JvmOverloads lets Java skip middle parameters
  • Believing defaults alone let you omit a middle parameter positionally
  • Confusing default-argument generation with method overloading at the JVM source level

context

resolving links…