Parameters with default values in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a parameter with a default value in Kotlin?

A parameter with a default value is a function parameter that has a preset value. If the caller does not provide an argument for it, the default value is used automatically.

beginner

How do you define a default value for a parameter in Kotlin?

You assign a value to the parameter in the function declaration using the equals sign, like fun greet(name: String = "Guest").

beginner

What happens if you call a Kotlin function without providing an argument for a parameter that has a default value?

The function uses the default value specified for that parameter instead of requiring an argument.

intermediate

Can you mix parameters with and without default values in Kotlin functions?

Yes, you can mix them. Parameters with default values can be placed after or before parameters without default values, but when calling the function, you must provide arguments for parameters without defaults.

beginner

Why are default parameter values useful in Kotlin?

They simplify function calls by reducing the number of arguments needed, avoid overloads, and make code easier to read and maintain.

How do you specify a default value for a parameter in Kotlin?

A By assigning a value in the function declaration, e.g., fun f(x: Int = 5)

B By setting the value inside the function body

C By using the keyword default before the parameter

D By declaring the parameter as nullable

In Kotlin, default values are assigned directly in the function parameter list using the equals sign.

What happens if you call a Kotlin function without an argument for a parameter that has a default value?

A The default value is used

B The program throws an error

C The parameter is set to null

D You must always provide all arguments

Kotlin uses the default value automatically if no argument is provided.

Can you omit arguments for parameters without default values when calling a Kotlin function?

A Only if the function is inline

B Yes, Kotlin fills them with zero

C Yes, Kotlin fills them with null

D No, you must provide arguments for all parameters without defaults

Parameters without default values require arguments when calling the function.

How can you call a Kotlin function and specify only some arguments when others have default values?

A By calling the function multiple times

B By using named arguments to specify which parameters you want to set

C By passing null for the missing arguments

D By using varargs

Named arguments let you specify only some parameters and rely on defaults for others.

Which of the following is a benefit of using default parameter values in Kotlin?

A Prevents null pointer exceptions

B Makes functions run faster

C Reduces the need for multiple overloaded functions

D Automatically documents the function

Default values reduce the need to write many overloaded versions of the same function.

Explain how default parameter values work in Kotlin and why they are useful.

Think about how you can make function calls simpler by not always giving every argument.

Describe how you can call a Kotlin function that has some parameters with default values and some without.

Consider how named arguments help when mixing parameters.

Practice

1. What happens when you call a Kotlin function with a parameter that has a default value but you don't provide an argument for it?
fun greet(name: String = "Guest") { println("Hello, $name!") }

easy

A. The function uses the default value for the missing parameter.

B. The function throws an error because the argument is missing.

C. The function ignores the parameter and prints nothing.

D. The function requires you to always provide the argument.

Solution

1. Step 1: Understand default parameter behavior

   In Kotlin, if a parameter has a default value, the function can be called without providing that argument.

2. Step 2: Apply to the example function

   Calling greet() will use the default value "Guest" for name, printing "Hello, Guest!".

3. Final Answer:

   The function uses the default value for the missing parameter. -> Option A

4. Quick Check:

   Default parameter means optional argument [OK]

Hint: If argument missing, default value is used automatically [OK]

Common Mistakes:

• Thinking missing argument causes error
• Assuming function ignores missing parameters
• Believing all parameters must be provided

2. Which of the following is the correct way to declare a Kotlin function with a default parameter value?

easy

A. fun add(a: Int, b: Int default 5) { return a + b }

B. fun add(a: Int = 5, b: Int) { return a + b }

C. fun add(a: Int, b: Int) = a + b = 5

D. fun add(a: Int, b: Int = 5) { return a + b }

Solution

1. Step 1: Check Kotlin syntax for default parameters

   In Kotlin, default values are assigned using = after the parameter type, like b: Int = 5.

2. Step 2: Validate each option

   fun add(a: Int, b: Int = 5) { return a + b } correctly uses b: Int = 5. fun add(a: Int = 5, b: Int) { return a + b } places default before non-default parameter, which is allowed but can cause ambiguity if called without named arguments. Options A and C have invalid syntax.

3. Final Answer:

   fun add(a: Int, b: Int = 5) { return a + b } -> Option D

4. Quick Check:

   Default value syntax = parameter: Type = value [OK]

Hint: Use '=' after type to set default value [OK]

Common Mistakes:

• Placing default value before type
• Using 'default' keyword instead of '='
• Assigning default outside parameter list

3. What is the output of the following Kotlin code?

fun multiply(x: Int, y: Int = 2) = x * y

println(multiply(4))

medium

A. 8

B. 4

C. Error: Missing argument for y

D. 2

Solution

1. Step 1: Identify default parameter usage

   The function multiply has a default value of 2 for y. Calling multiply(4) means x=4 and y=2.

2. Step 2: Calculate the result

   Multiply 4 by 2 to get 8.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   Default y=2 used, 4*2=8 [OK]

Hint: If argument missing, default value is used [OK]

Common Mistakes:

• Expecting error for missing argument
• Using only first argument as output
• Confusing default value with zero

4. Identify the error in this Kotlin function declaration:

fun greet(name: String = "User", age: Int) {
    println("Hello, $name! You are $age years old.")
}

medium

A. Cannot use default values with String parameters.

B. Default parameter must be last or followed by named arguments.

C. Function must return a value if default parameters are used.

D. No error, function is correct.

Solution

1. Step 1: Check parameter order rules

   In Kotlin, parameters with default values should be placed after parameters without default values, or you must use named arguments when calling.

2. Step 2: Analyze given function

   Here, name has a default but comes before age which has no default. This causes a problem when calling without named arguments.

3. Final Answer:

   Default parameter must be last or followed by named arguments. -> Option B

4. Quick Check:

   Default parameters after non-default or use named args [OK]

Hint: Place default parameters after non-default ones [OK]

Common Mistakes:

• Putting default parameters before required ones
• Assuming all parameters can have defaults anywhere
• Ignoring named argument calls

5. You want to write a Kotlin function formatMessage that takes a message and an optional prefix with default value "Info:". It should return the combined string. Which function correctly implements this and allows calling with or without the prefix?

hard

A. fun formatMessage(prefix: String = "Info:", message: String) = "$prefix $message"

B. fun formatMessage(message: String, prefix: String) = "$prefix $message"

C. fun formatMessage(message: String, prefix: String = "Info:") = "$prefix $message"

D. fun formatMessage(message: String = "Info:", prefix: String) = "$prefix $message"

Solution

1. Step 1: Define function with default parameter last

   The optional parameter prefix with default value should come after the required message parameter.

2. Step 2: Check each option

   fun formatMessage(message: String, prefix: String = "Info:") = "$prefix $message" correctly places prefix last with default. fun formatMessage(prefix: String = "Info:", message: String) = "$prefix $message" places default before required, which can cause call issues. Options C and D lack default for prefix or have wrong order.

3. Final Answer:

   fun formatMessage(message: String, prefix: String = "Info:") = "$prefix $message" -> Option C

4. Quick Check:

   Default last parameter enables optional argument [OK]

Hint: Put default parameters after required ones for easy calls [OK]

Common Mistakes:

• Placing default parameter before required parameter
• Not providing default value for optional parameter
• Confusing parameter order causing call errors