60 Latest Kotlin Interview Questions

Introduction

Kotlin is a modern programming language that has gained popularity in recent years for its simplicity, conciseness, and compatibility with Java. As a student preparing for a Kotlin interview, it’s essential to have a solid understanding of the language’s fundamentals and its features. This will help you showcase your knowledge and skills during the interview process.

In this guide, we will provide you with a set of common Kotlin interview questions that students may encounter. These questions cover various aspects of the language, including syntax, object-oriented programming, functional programming, and more. By familiarizing yourself with these questions and practicing your answers, you can gain confidence and increase your chances of success in your Kotlin interview.

So, let’s dive into the world of Kotlin interview questions and help you prepare for your upcoming interviews. Remember to take your time, understand the questions thoroughly, and provide clear and concise answers. Good luck!

Basic Questions

1. What is Kotlin?

Kotlin is a statically-typed programming language that runs on the Java Virtual Machine (JVM) and can also be compiled to JavaScript or native code. It was developed by JetBrains and was first released in 2011. Kotlin is designed to be fully interoperable with Java, which means it can be used alongside existing Java code and libraries. It aims to be a more concise, expressive, and safer alternative to Java.

2. Who is the developer of Kotlin?

Kotlin was developed by JetBrains, a software development company based in Prague, Czech Republic. JetBrains initially created Kotlin as an alternative programming language for their own internal use but later released it as an open-source language in 2012.

3. What is the difference between Kotlin and Java?

4. Why should one switch to Kotlin from Java?

There are several reasons why developers may consider switching from Java to Kotlin:

1. Concise syntax: Kotlin has a more expressive and concise syntax compared to Java, which reduces boilerplate code and increases productivity.
2. Null safety: Kotlin has built-in null safety features, reducing the occurrence of null pointer exceptions.
3. Interoperability: Kotlin is fully interoperable with Java, allowing developers to use existing Java libraries and frameworks seamlessly.
4. Functional programming support: Kotlin provides powerful functional programming features, such as lambda expressions and higher-order functions, which can simplify code and enable more expressive programming.
5. Coroutines: Kotlin has built-in support for coroutines, which allows for asynchronous programming in a more readable and structured manner compared to traditional thread-based concurrency in Java.
6. Tooling and community: Kotlin is backed by JetBrains, a company known for its strong tooling support. It has a growing and active community, with increasing adoption in the Android development ecosystem.

5. How does null safety work in Kotlin?

In Kotlin, null safety is enforced at the language level to prevent null pointer exceptions. Variables in Kotlin can be declared as nullable or non-null.

• Nullable type: A nullable type is denoted by adding a ? after the type name. It allows the variable to hold a null value.
• Non-null type: A non-null type does not allow null values, and the compiler ensures that null checks are performed before accessing the variable.

Example:

// Nullable type
var nullableString: String? = "Hello"
nullableString = null // Valid assignment

// Non-null type
var nonNullString: String = "World"
// nonNullString = null // Compilation error, cannot assign null to non-null variable

// Null check
if (nullableString != null) {
    val length: Int = nullableString.length // No null pointer exception
} else {
    // Handle the null case
}

6. What are the types of constructors in Kotlin?

In Kotlin, there are two types of constructors:

1. Primary constructor: The primary constructor is defined as part of the class header. It can have parameters and initialization code. It is typically used to define the class properties.
2. Secondary constructor: A class can have one or more secondary constructors. They are defined inside the class body and are prefixed with the constructor keyword. Secondary constructors allow additional ways to initialize the class or provide alternative parameter sets.

Example:

class Person(val name: String, var age: Int) {
    // Primary constructor

    constructor(name: String) : this(name, 0) {
        // Secondary constructor
        // Calls the primary constructor with default age value
    }

    constructor() : this("Unknown", 0) {
        // Secondary constructor
        // Calls the primary constructor with default name and age values
    }
}

fun main() {
    val person1 = Person("John", 30)
    val person2 = Person("Alice")
    val person3 = Person()

    println(person1.name) // Output: John
    println(person2.age)  // Output: 0
    println(person3.name) // Output: Unknown
}

7. What is a data class in Kotlin?

In Kotlin, a data class is a special type of class that is primarily used to hold data/state. It automatically generates useful functions such as equals(), hashCode(), toString(), and copy(). Data classes are often used for modeling entities, DTOs (Data Transfer Objects), or immutable data containers.

Example:

data class Person(val name: String, val age: Int)

fun main() {
    val person1 = Person("John", 30)
    val person2 = Person("John", 30)

    println(person1 == person2) // Output: true (equals() comparison)
    println(person1.hashCode()) // Output: 998420214 (hashCode() value)
    println(person1.toString()) // Output: Person(name=John, age=30)

    val person3 = person1.copy(age = 40)
    println(person3) // Output: Person(name=John, age=40)
}

8. How do you declare variables in Kotlin?

In Kotlin, variables can be declared using the val or var keyword.

• val: It declares an immutable (read-only) variable, similar to the final keyword in Java. Once assigned, its value cannot be changed.
• var: It declares a mutable variable. Its value can be changed after assignment.

Example:

val pi: Double = 3.14
val name = "John" // Type inference

var age: Int = 30
age = 31 // Valid reassignment

// Compiler infers the type based on the initial value
val message = "Hello, World!"

9. What is the difference between ‘val’ and ‘var’ in Kotlin? (in tabular form)

10. What are some of the key features of Kotlin?

Some key features of Kotlin include:

1. Concise syntax: Kotlin reduces boilerplate code and allows developers to express their intent more clearly.
2. Null safety: Kotlin enforces null safety at the language level, reducing null pointer exceptions.
3. Interoperability: Kotlin is fully interoperable with Java, allowing seamless integration with existing Java code and libraries.
4. Extension functions: Kotlin allows adding new functions to existing classes without modifying their source code.
5. Coroutines: Kotlin provides built-in support for coroutines, enabling asynchronous programming in a more readable and structured manner.
6. Smart casts: Kotlin’s type system allows automatic smart casts, reducing the need for explicit type checks and casts.
7. Data classes: Kotlin’s data classes automatically generate useful functions for modeling data/state.
8. Functional programming features: Kotlin supports functional programming constructs like lambda expressions, higher-order functions, and immutable collections.
9. Object-oriented programming: Kotlin is fully object-oriented and supports classes, inheritance, interfaces, and other object-oriented concepts.

11. What does the ?. (Safe call) operator do in Kotlin?

The ?. operator, known as the safe call operator, is used to safely access properties or call methods on nullable objects. It returns null if the object reference is null, without throwing a null pointer exception.

Example:

val name: String? = getNullableName()
val length: Int? = name?.length

println(length) // Output: null if 'name' is null, otherwise the length of the string

In the example above, if name is null, the length variable will be assigned null instead of throwing a null pointer exception. This operator is especially useful when working with nullable types to prevent unexpected crashes.

12. Explain the ‘when’ expression in Kotlin and how it differs from a switch statement in Java.

In Kotlin, the when expression is a powerful construct used for multi-way branching. It is similar to the switch statement in Java but provides more flexibility and functionality.

The when expression can be used as a replacement for complex if-else if chains or traditional switch statements. It allows matching a value against multiple cases and executing corresponding code blocks.

Differences between when in Kotlin and switch in Java:

1. Expression-based: In Kotlin, when is an expression that returns a value, whereas switch in Java is a statement.
2. Pattern matching: Kotlin’s when supports more powerful pattern matching capabilities, allowing cases to match against complex conditions, ranges, types, or even custom objects.
3. Multiple matching cases: Kotlin’s when allows multiple cases to be combined together, reducing code duplication.
4. Smart casts: In Kotlin, when a case is matched against a type, smart casts are automatically applied, eliminating the need for explicit type casts.
5. No fall-through: Kotlin’s when does not support fall-through by default, unlike Java’s switch. Each case is executed independently, and there is no need for explicit break statements.
6. Default case: In Kotlin, the else keyword is used as the default case, which is executed when no other cases match.

Example:

val day = 5
val dayString = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    in 3..5 -> "Wednesday to Friday"
    else -> "Weekend"
}

println(dayString) // Output: "Wednesday to Friday"

In the example above, the when expression matches the value of the day variable against different cases. If the value is 3, 4, or 5, the corresponding string “Wednesday to Friday” is assigned to dayString.

13. What are Kotlin Coroutines?

Kotlin Coroutines are a concurrency design pattern and framework for asynchronous programming. They provide a way to write highly efficient, non-blocking code that looks like sequential code. Coroutines simplify the handling of asynchronous operations, such as network requests or file I/O, without blocking the main thread or resorting to callbacks.

Example:

import kotlinx.coroutines.*
import java.time.LocalDateTime

fun main() = runBlocking {
    println("Start: ${LocalDateTime.now()}")

    val result1 = async { fetchDataAsync(1) }
    val result2 = async { fetchDataAsync(2) }
    val result3 = async { fetchDataAsync(3) }

    val combinedResult = result1.await() + result2.await() + result3.await()
    println("Combined Result: $combinedResult")

    println("End: ${LocalDateTime.now()}")
}

suspend fun fetchDataAsync(id: Int): String {
    delay(1000) // Simulating network request or blocking operation
    return "Result for $id"
}

In the example above, runBlocking is used to create a coroutine scope. The fetchDataAsync function is marked with suspend, indicating that it can be suspended and resumed without blocking the main thread.

14. What is an extension function in Kotlin?

An extension function in Kotlin allows adding new functions to existing classes without modifying their source code. Extension functions enhance the functionality of a class without the need for subclassing or modifying the original class.

Example:

fun String.addExclamation(): String {
    return "$this!"
}

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val temp = this[index1]
    this[index1] = this[index2]
    this[index2] = temp
}

fun main() {
    val greeting = "Hello"
    val modifiedGreeting = greeting.addExclamation()
    println(modifiedGreeting) // Output: "Hello!"

    val numbers = mutableListOf(1, 2, 3)
    numbers.swap(0, 2)
    println(numbers) // Output: [3, 2, 1]
}

In the example above, an extension function addExclamation is defined on the String class. It adds an exclamation mark to a string. Another extension function swap is defined on the MutableList<Int> class, allowing swapping elements at specified indices.

15. What are high-order functions in Kotlin?

High-order functions in Kotlin are functions that can accept other functions as parameters or return functions. They allow functions to be treated as first-class citizens, enabling functional programming paradigms.

Example:

fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

fun add(x: Int, y: Int): Int {
    return x + y
}

fun subtract(x: Int, y: Int): Int {
    return x - y
}

fun main() {
    val result1 = performOperation(5, 3, ::add)
    println(result1) // Output: 8



    val result2 = performOperation(10, 7, ::subtract)
    println(result2) // Output: 3
}

In the example above, the performOperation function is a high-order function that accepts two integers x and y and a function operation that takes two integers and returns an integer.

16. What is the ‘apply’ function in Kotlin?

The apply function in Kotlin is a scoping function that allows configuring properties of an object within a specified scope. It returns the object itself after the configuration is applied. The apply function is commonly used for initializing or configuring objects concisely.

Example:

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("John", 30).apply {
        name = "Alice"
        age = 25
    }

    println(person) // Output: Person(name=Alice, age=25)
}

In the example above, the apply function is called on a Person object. Inside the scope of the apply function, the name and age properties of the Person object are modified. The modified object is then assigned to the person variable.

17. What are Kotlin companion objects?

In Kotlin, a companion object is a special object that is tied to the class in which it is defined. It is similar to static members in Java classes. Companion objects can access private members of the class and provide a way to define static members or perform static-like operations within the class.

Example:

class MyClass {
    companion object {
        const val MAX_COUNT = 10

        fun doSomething() {
            // Perform some operation
        }
    }
}

fun main() {
    println(MyClass.MAX_COUNT) // Output: 10
    MyClass.doSomething()
}

In the example above, the MyClass defines a companion object using the companion keyword. Inside the companion object, a constant MAX_COUNT is defined, which can be accessed without creating an instance of the class. The companion object also defines a static-like function doSomething(), which can be called using the class name.

18. How does exception handling in Kotlin differ from Java?

Exception handling in Kotlin is similar to Java but with a more concise syntax. Kotlin introduces the try expression, which allows using a more functional programming style for exception handling.

Example:

fun divide(a: Int, b: Int): Int {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        println("Division by zero is not allowed.")
        0
    }
}

fun main() {
    val result = divide(10, 0)
    println("Result: $result")
}

In the example above, the divide function attempts to divide two integers. Inside the try block, the division operation is performed. If an ArithmeticException occurs (division by zero), the catch block is executed. The catch block prints an error message and returns a default value of 0.

19. What is the use of the ‘with’ function in Kotlin?

The with function in Kotlin is a scoping function that provides a way to operate on an object within a specified scope. It allows concise access to the members of the object without the need to repeat the object reference.

Example:

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("John", 30)

    with(person) {
        name = "Alice"
        age = 25
    }

    println(person) // Output: Person(name=Alice, age=25)
}

In the example above, the with function is used to operate on the person object. Inside the scope of the with function, the name and age properties of the person object are modified directly, without repeating the person reference.

20. What are the collections in Kotlin?

Kotlin provides a rich set of collection classes for working with groups of elements. Some commonly used collection classes in Kotlin include List, Set, and Map.

Example:

fun main() {
    // List
    val numbers: List<Int> = listOf(1, 2, 3, 4, 5)
    println(numbers) // Output: [1, 2, 3, 4, 5]

    // Set
    val uniqueNumbers: Set<Int> = setOf(1, 2, 3, 4, 5, 5)
    println(uniqueNumbers) // Output: [1, 2, 3, 4, 5]

    // Map
    val userAges: Map<String, Int> = mapOf("Alice" to 25, "Bob" to 30, "Charlie" to 35)
    println(userAges) // Output: {Alice=25, Bob=30, Charlie=35}
}

In the example above, three different collection types are demonstrated:

• List is an ordered collection that allows duplicate elements. The listOf function is used to create an immutable list.
• Set is an unordered collection that does not allow duplicate elements. The setOf function is used to create an immutable set.
• Map is a collection of key-value pairs. The mapOf function is used to create an immutable map.

Intermediate Questions

1. What is the Elvis operator in Kotlin?

The Elvis operator in Kotlin is represented by the symbol ?:. It is a shorthand notation for handling null values. It allows you to provide a default value that will be used if the expression on the left side of the operator is null. If the expression is not null, its value will be returned.

Here’s an example:

val nullableValue: String? = null
val result = nullableValue ?: "Default Value"
println(result) // Output: Default Value

val nonNullableValue: String? = "Hello"
val result2 = nonNullableValue ?: "Default Value"
println(result2) // Output: Hello

In the first example, since nullableValue is null, the default value “Default Value” is assigned to result. In the second example, nonNullableValue is not null, so its value “Hello” is assigned to result2.

2. Explain the use of extension functions in Kotlin. How do they differ from regular member functions?

Extension functions in Kotlin allow you to add new functions to existing classes, including classes that you don’t own or have access to modify. These functions are defined outside the class but can be called as if they were regular member functions.

Here are a few key points about extension functions and how they differ from regular member functions:

• Extension functions can be defined for both classes and nullable types.
• They are defined using the fun keyword, followed by the name of the class being extended, a dot (.), and then the name of the function.
• Extension functions do not modify the original class; they provide additional functionality from outside.
• Extension functions can be called on an instance of the extended class just like regular member functions.
• Extension functions are resolved statically, based on the declared type of the variable, not the runtime type.
• They can access the public properties and methods of the extended class.

Here’s an example to illustrate the use of an extension function:

fun String.isPalindrome(): Boolean {
    val reversed = this.reversed()
    return this == reversed
}

fun main() {
    val word = "level"
    println(word.isPalindrome()) // Output: true
}

In this example, we define an extension function isPalindrome() for the String class. It checks whether the string is a palindrome. We can then call this function on any String object, as shown in the main() function.

3. How does Kotlin handle null safety and what are the operators used to handle it?

Kotlin provides built-in null safety features to prevent null pointer exceptions. It enforces compile-time checks to ensure that nullable types are handled correctly. There are two main operators used to handle null safety in Kotlin: the safe call operator (?.) and the not-null assertion operator (!!).

• Safe Call Operator (?.): It allows accessing properties or invoking methods on a nullable object without throwing a null pointer exception. If the object is null, the expression returns null instead of throwing an exception.

val length: Int? = nullableString?.length

In the example above, length will be null if nullableString is null.

• Not-Null Assertion Operator (!!): It converts a nullable type to a non-null type. If the object is null, it throws a NullPointerException. This operator should be used with caution because it bypasses the compile-time null safety checks.

val length: Int = nullableString!!.length

In the example above, if nullableString is null, a NullPointerException will be thrown. Kotlin also encourages the use of safe calls and safe casts to handle null safety, along with the Elvis operator (?:) to provide default values for nullable objects.

4. How are Lambda expressions used in Kotlin?

Lambda expressions in Kotlin allow you to define anonymous functions concisely. They can be used wherever a function type is expected, such as in higher-order functions, functional interfaces, and collection operations.

Lambda expressions have the following syntax:

val lambdaName: (parameters) -> ReturnType = { arguments -> body }

Here’s an example to demonstrate the use of a lambda expression:

val numbers = listOf(1, 2, 3, 4, 5)

val doubled = numbers.map { it * 2 }

println(doubled) // Output: [2, 4, 6, 8, 10]

In this example, we have a list of numbers. We use the map function, which takes a lambda expression as an argument. The lambda expression it * 2 multiplies each element by 2. The result is a new list doubled with the doubled values of the original list.

5. What is a sealed class in Kotlin?

In Kotlin, a sealed class is a class that can have a limited number of subclasses defined within it. It is useful when you want to represent a restricted hierarchy of classes, where all possible subclasses are known and finite.

Here’s an example of a sealed class in Kotlin:

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handleResult(result: Result) {
    when (result) {
        is Result.Success -> println("Success: ${result.data}")
        is Result.Error -> println("Error: ${result.message}")
        Result.Loading -> println("Loading...")
    }
}

fun main() {
    val successResult = Result.Success("Data")
    val errorResult = Result.Error("Something went wrong")
    val loadingResult = Result.Loading

    handleResult(successResult) // Output: Success: Data
    handleResult(errorResult) // Output: Error: Something went wrong
    handleResult(loadingResult) // Output: Loading...
}

In this example, Result is a sealed class that represents the result of an operation. It has three subclasses: Success, Error, and Loading. The handleResult function uses a when expression to handle different cases based on the type of the Result object passed to it.

6. What is ‘infix’ in Kotlin?

In Kotlin, the infix modifier is used to define an infix function. An infix function allows you to call a function with a single argument using infix notation, without the need for parentheses or the dot operator. It is a way to make the function call more readable and expressive.

To define an infix function, you need to use the infix keyword before the function declaration.

Here’s an example of using an infix function in Kotlin:

infix fun Int.isHalfOf(number: Int): Boolean {
    return this * 2 == number
}

fun main() {
    val a = 5
    val b = 10

    println(a.isHalfOf(b)) // Output: true
    println(a isHalfOf b) // Output: true (using infix notation)
}

In this example, we define an infix function isHalfOf for the Int class. It checks if the receiver (this) multiplied by 2 is equal to the argument number. We can call this function using both regular notation and infix notation.

7. Explain how to implement Singleton in Kotlin.

In Kotlin, a Singleton is implemented using an object declaration. An object declaration creates a singleton instance implicitly, and it can contain properties, methods, and initialization code. The instance is lazily initialized and is thread-safe by default.

Here’s an example of implementing a Singleton in Kotlin:

object MySingleton {
    fun doSomething() {
        println("Singleton: Doing something")
    }
}

fun main() {
    MySingleton.doSomething() // Output: Singleton: Doing something
}

In this example, MySingleton is a Singleton object that contains a single method doSomething(). The object can be accessed directly without creating an instance using the object name followed by the method call.

8. What are companion objects in Kotlin? How do they differ from the ‘static’ keyword in Java?

In Kotlin, a companion object is a special object that is tied to a class and can be used to define static members specific to that class. It is similar to the static keyword in Java but provides more flexibility and supports inheritance.

Here are a few key points about companion objects:

• Each class can have only one companion object.
• Companion objects can access private members of the class.
• They can implement interfaces and inherit from other classes.
• Companion object members can be accessed using the class name, similar to static members in Java.

Here’s an example to illustrate the use of a companion object:

class MyClass {
    companion object {
        fun doSomething() {
            println("Companion Object: Doing something")
        }
    }
}

fun main() {
    MyClass.doSomething() // Output: Companion Object: Doing something
}

In this example, MyClass has a companion object defined using the companion keyword. Inside the companion object, we define a function doSomething(). The companion object can be accessed using the class name followed by the function call.

9. What is the difference between ‘const’ and ‘val’?

In Kotlin, const and val are used to declare constants, but they have different characteristics:

• const: It is used for compile-time constants. The value of a const property is known at compile time and is replaced directly in the code where it is used. const can only be used for top-level or member-level val properties that are initialized with a compile-time constant or a value of another const val.

const val PI = 3.14159

• val: It is used for runtime constants. The value of a val property is known at runtime and cannot be changed once initialized. It is similar to a read-only variable.

val radius = 5.0

Here’s an example that demonstrates the difference:

const val A = 10
val B = 20

fun main() {
    println(A + B) // Output: 30
}

In this example, A is a const compile-time constant, while B is a runtime constant. The expression A + B is evaluated at compile time, and the result is directly replaced in the code, resulting in 30 as the output.

10. Explain what destructuring declaration is in Kotlin and its uses.

Destructuring declarations in Kotlin allow you to extract the values from an object or data structure and assign them to individual variables. It simplifies working with complex data types by unpacking their contents into separate variables.

Here’s an example to demonstrate the use of destructuring declarations:

data class Person(val name: String, val age: Int)

fun main() {
    val person = Person("John", 25)
    val (name, age) = person

    println("Name: $name, Age: $age") // Output: Name: John, Age: 25
}

In this example, we have a Person data class with properties name and age. We create an instance of Person named person. Using a destructuring declaration, we extract the values of name and age from person and assign them to individual variables name and age. We can then use these variables independently.

11. What is the difference between List and MutableList in Kotlin?

12. What is the difference between ‘apply’ and ‘with’ in Kotlin?

13. How are default arguments used in Kotlin?

Default arguments in Kotlin allow you to specify default values for function parameters. When a function is called, if an argument is not provided for a parameter with a default value, the default value is used.

Here’s an example to demonstrate the use of default arguments:

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

fun main() {
    greet() // Output: Hello, Anonymous!
    greet("John") // Output: Hello, John!
}

In this example, the greet() function has a default argument for the name parameter, which is set to “Anonymous”. When the function is called without an argument, the default value is used. When the function is called with the argument “John”, it overrides the default value.

14. How does exception handling in Kotlin differ from Java?

Exception handling in Kotlin is similar to Java, but Kotlin introduces some improvements to make exception handling more concise and expressive.

Here’s an example to illustrate exception handling in Kotlin:

fun divide(a: Int, b: Int): Int {
    return try {
        a / b
    } catch (e: ArithmeticException) {
        println("Division by zero is not allowed")
        0
    }
}

fun main() {
    val result = divide(10, 0)
    println("Result: $result") // Output: Division by zero is not allowed. Result: 0
}

In this example, the divide() function attempts to divide two numbers (a and b). If an ArithmeticException occurs, it catches the exception, prints a message, and returns a default value of 0.

Kotlin introduces the following improvements in exception handling compared to Java:

• Kotlin does not enforce checked exceptions. All exceptions in Kotlin are unchecked.
• Kotlin replaces the throws clause with the throws keyword. Instead, you specify the exceptions that a function may throw in the function signature using the throws keyword.
• Kotlin’s try expression can have a return value, allowing you to assign the result of the try-catch block to a variable directly.
• The use of semicolons is optional in Kotlin.

15. What is a ‘when’ expression in Kotlin?

The when expression in Kotlin is similar to a switch statement in other languages. It allows you to match a value against multiple branches and execute the corresponding block of code based on the matching condition.

Here’s an example to illustrate the use of a when expression:

fun describe(number: Int) {
    when (number) {
        1 -> println("One")
        2, 3 -> println("Two or Three")
        in 4..10 -> println("Between Four and Ten")
        else -> println("Other")
    }
}

fun main() {
    describe(2) // Output: Two or Three
    describe(7) // Output: Between Four and Ten
    describe(11) // Output: Other
}

In this example, the describe() function takes an Int parameter number. The when expression matches the value of number against different cases and executes the corresponding block of code. The else branch is used as a default case if none of the other conditions match.

16. What are higher-order functions in Kotlin?

Higher-order functions in Kotlin are functions that can take other functions as parameters or return functions as results. They treat functions as first-class citizens, allowing you to work with them in a flexible and expressive way.

Here’s an example to illustrate the use of higher-order functions:

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return operation(x, y)
}

fun add(a: Int, b: Int): Int {
    return a + b
}

fun multiply(a: Int, b: Int): Int {
    return a * b
}

fun main() {
    val result1 = calculate(10, 5, ::add)
    println(result1) // Output: 15

    val result2 = calculate(10, 5, ::multiply)
    println(result2) // Output: 50
}

In this example, we have a higher-order function calculate() that takes two Int parameters x and y, along with a function operation that takes two Int parameters and returns an Int. Inside calculate(), we invoke the operation function with the provided x and y values.

17. What is the difference between Sequence and Collection in Kotlin?

18. How can you create a thread in Kotlin?

In Kotlin, you can create a thread by using the Thread class or the higher-level kotlin.concurrent.thread function. Both options allow you to execute code concurrently.

Here’s an example of creating a thread using the Thread class:

fun main() {
    val thread = Thread {
        // Code to be executed in the thread
        println("Thread is running")
    }

    thread.start() // Start the thread
}

In this example, we create a Thread instance by passing a lambda expression to its constructor. The lambda expression contains the code to be executed in the thread. We then call the start() method to start the thread.

Alternatively, you can use the kotlin.concurrent.thread function:

fun main() {
    val thread = thread {
        // Code to be executed in the thread
        println("Thread is running")
    }

    thread.start() // Start the thread
}

The kotlin.concurrent.thread function simplifies the creation of threads by providing a more concise syntax.

19. What is the difference between ‘let’, ‘run’, and ‘also’ in Kotlin?

The functions let, run, and also in Kotlin are scoping functions that allow you to perform operations on an object within a limited scope. Although they have similarities, they differ in terms of the context in which they are executed and the return value.

Here’s a comparison of let, run, and also:

In the examples above, nullableString, person, and list are objects on which the scoping functions are applied.

• let takes the object reference as the context (it) and returns the result of the lambda expression. It is useful for performing null-safe operations or transforming the object.
• run also takes the object reference as the context (this) but returns the result of the lambda expression. It is often used for scoping operations or accessing properties and functions of the object concisely.
• also takes the object reference as the context (it`) and returns the object itself. It is useful for performing additional actions on the object while keeping the original object intact.

20. What are inline, noinline, and crossinline in Kotlin?

In Kotlin, inline, noinline, and crossinline are used to modify the behavior of higher-order functions.

• inline: It is a keyword that suggests the compiler to perform inlining. Inlining means that the code inside the function is directly substituted at the call site, which can improve performance. Inlining is suitable for small functions or lambdas.
• noinline: It is a keyword used to specify that a lambda parameter should not be inlined when used as an argument. It allows the lambda to be stored or passed as a parameter to other functions.
• crossinline: It is a keyword used to enforce that a lambda parameter cannot have a non-local return. It prevents the use of return statements inside the lambda to jump out of the enclosing function.

Here’s an example that demonstrates the use of inline, noinline, and crossinline:

inline fun higherOrderFunction(block: () -> Unit, noinline lambda: () -> Unit) {
    println("Executing block...")
    block()
    println("Executing lambda...")
    lambda()
}

fun main() {
    higherOrderFunction({
        println("Inside block")
        return // Error: Non-local returns are not allowed with crossinline parameters
    }) {
        println("Inside lambda")
    }
}

In this example, the higherOrderFunction is an inline higher-order function that takes a block lambda and a lambda lambda as parameters. The block parameter is inlined by default, while the lambda parameter is marked as noinline.

Advanced Questions

1. What are the key differences between Coroutines and Threads in Kotlin?

Coroutines and threads are concurrency mechanisms in Kotlin, but they differ in several key aspects:

1. Concurrency model: Threads are managed by the operating system, while coroutines are lightweight and managed by the developer’s code.
2. Concurrency cost: Creating and switching between threads has a higher overhead compared to coroutines, which are much lighter in terms of resource usage.
3. Synchronization: Threads require explicit synchronization mechanisms like locks and semaphores to avoid data races. Coroutines, on the other hand, can use suspending functions and structured concurrency to ensure safe access to shared data.

Here’s an example demonstrating the difference between threads and coroutines:

// Using threads
import kotlin.concurrent.thread

fun main() {
    val thread1 = thread {
        println("Thread 1: Before sleep")
        Thread.sleep(1000)
        println("Thread 1: After sleep")
    }

    val thread2 = thread {
        println("Thread 2: Before sleep")
        Thread.sleep(1000)
        println("Thread 2: After sleep")
    }

    thread1.join()
    thread2.join()
    println("All threads completed")
}

// Using coroutines
import kotlinx.coroutines.*

fun main() = runBlocking {
    val coroutine1 = launch {
        println("Coroutine 1: Before delay")
        delay(1000)
        println("Coroutine 1: After delay")
    }

    val coroutine2 = launch {
        println("Coroutine 2: Before delay")
        delay(1000)
        println("Coroutine 2: After delay")
    }

    coroutine1.join()
    coroutine2.join()
    println("All coroutines completed")
}

In the thread example, two threads are created and put to sleep for 1 second each. In the coroutine example, two coroutines are launched using launch and suspended using delay for 1 second each. Both examples output similar results, but coroutines have significantly lower overhead compared to threads.

2. What is the difference between ‘suspend’ and ‘resume’ in Kotlin Coroutines?

In Kotlin coroutines, ‘suspend‘ and ‘resume‘ are not separate concepts but rather part of the overall coroutine lifecycle.

When a coroutine encounters a ‘suspend’ function, it temporarily suspends its execution, allowing other coroutines to proceed. The suspension point is usually used for performing non-blocking or long-running operations. Once the suspend function completes, the coroutine resumes its execution.

Here’s an example that demonstrates the use of ‘suspend’ functions:

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000) // Simulating a network request
    return "Data from server"
}

fun main() = runBlocking {
    val job = launch {
        println("Coroutine started")
        val data = fetchData()
        println("Received data: $data")
    }

    println("Do something else")
    job.join()
}

In this example, the fetchData() function is marked as ‘suspend’. When job is launched, it starts executing the coroutine body. When fetchData() is called, it suspends the coroutine for 1 second using delay(1000), allowing other coroutines to run. After the delay, the coroutine resumes execution and prints the received data.

3. How do you create a custom getter or setter in Kotlin?

In Kotlin, you can create custom getters and setters for properties using the get() and set() keywords. Here’s how you can define custom getters and setters:

class Person {
    var name: String = ""
        get() {
            println("Getting name")
            return field
        }
        set(value) {
            println("Setting name")
            field = value
        }
}

fun main() {
    val person = Person()
    person.name = "John" // Calls the custom setter
    println(person.name) // Calls the custom getter
}

In this example, the Person class has a property name with a custom getter and setter. The getter prints a message and returns the value of the property (field). The setter prints a message and assigns the value to the property (field).

When person.name = "John" is called, the custom setter is invoked. When println(person.name) is called, the custom getter is invoked.

4. Explain the internal working of the ‘let’ function in Kotlin.

The let function in Kotlin is a scoping function that allows you to perform operations on an object within a given scope and return a result. It is often used for null-checking and transforming nullable objects.

Internally, the let function takes the object it is invoked on as a parameter and executes a lambda expression on it. The lambda expression provides a temporary scope where the object is non-null and can be accessed safely.

Here’s an example that demonstrates the usage of the let function:

fun processText(text: String?) {
    text?.let { // Uses the let function for null-checking
        println("Processing: $it")
        // Perform operations on the non-null 'text'
    }
}

fun main() {
    processText("Hello") // Output: Processing: Hello
    processText(null)    // No output
}

In this example, the processText function takes a nullable text parameter. The let function is used to check if text is non-null. Within the let scope, you can safely perform operations on the non-null text variable.

5. How does the ‘reified’ keyword work in Kotlin and when might you use it?

The reified keyword in Kotlin is used in combination with inline functions and type parameters to access type information at runtime. Normally, due to type erasure, type parameters are not available at runtime. However, with reified, you can retrieve the type information within the inline function.

Here’s an example that demonstrates the usage of the reified keyword:

inline fun <reified T> printType() {
    val typeName = T::class.simpleName
    println("Type: $typeName")
}

fun main() {
    printType<Int>() // Output: Type: Int
    printType<String>() // Output: Type: String
}

In this example, the printType function is an inline function with a type parameter T marked as reified. Within the function, T::class retrieves the runtime class of the type parameter. The simpleName property is then used to get the name of the type.

When printType<Int>() is called, the type parameter T is resolved to Int, and the output is “Type: Int”. Similarly, when printType<String>() is called, the output is “Type: String”.

6. Explain the usage and benefits of sealed classes in Kotlin.

Sealed classes in Kotlin are used to represent restricted class hierarchies, where all subclasses of a sealed class are known and defined within the same file. Sealed classes are commonly used with when expressions, providing a powerful way to handle a limited set of possibilities.

Benefits of sealed classes:

1. Restricted hierarchy: Sealed classes define a closed set of subclasses within the same file, ensuring that all possible subclasses are known and limited. This allows exhaustive handling of subclasses in when expressions.
2. Data encapsulation: Sealed classes encapsulate related subclasses and their behavior, making it easier to reason about the possible states or variations.
3. Compiler support: The Kotlin compiler can perform exhaustive checks on when expressions involving sealed classes, ensuring that all possible cases are handled. This helps catch potential bugs at compile-time.

Here’s an example that demonstrates the usage of sealed classes:

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()
object Loading : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
        Loading -> println("Loading")
    }
}

fun main() {
    val result1 = Success("Data")
    val result2 = Error("Error message")
    val result3 = Loading

    processResult(result1) // Output: Success: Data
    processResult(result2) // Output: Error: Error message
    processResult(result3) // Output: Loading
}

In this example, the Result sealed class defines three subclasses: Success, Error, and Loading. The processResult function uses a when expression to handle each possible case. The sealed nature of the class hierarchy ensures that all cases are handled, and the compiler performs exhaustiveness checks.

7. Explain how ‘lateinit var’ works in Kotlin.

In Kotlin, the lateinit modifier is used with the var keyword to declare a non-null property that is initialized later. It allows you to postpone the initialization of a property and explicitly mark it as non-null, even though it doesn’t have an initial value when declared.

Here’s an example that demonstrates the usage of lateinit var:

class Person {
    lateinit var name: String

    fun initialize() {
        name = "John"
    }

    fun printName() {
        println(name)
    }
}

fun main() {
    val person = Person()
    person.initialize()
    person.printName() // Output: John
}

In this example, the Person class has a lateinit var name: String property. The property is declared without an initial value and marked as lateinit. The initialize function is responsible for assigning a value to the name property.

When person.initialize() is called, the name property is initialized with the value “John”. Later, when person.printName() is called, the initialized value is printed.

8. What are Typealiases in Kotlin and how would you use them?

Typealiases in Kotlin allow you to create alternative names (aliases) for existing types. They are especially useful when working with complex or nested types, providing more readable and expressive code.

Here’s an example that demonstrates the usage of typealiases:

typealias Name = String
typealias EmployeeId = Int

data class Employee(val name: Name, val id: EmployeeId)

fun main() {
    val employee = Employee("John", 123)
    println(employee.name) // Output: John
    println(employee.id) // Output: 123
}

In this example, the typealias keyword is used to create two type aliases: Name for String and EmployeeId for Int. These aliases make the code more readable and provide meaningful names for the respective types.

The Employee class uses the type aliases for its properties name and id. When accessing these properties, the code is more expressive, and the intent is clearer.

9. Explain what inline classes are and when they might be used in Kotlin.

Inline classes in Kotlin are a lightweight way to define types with a single property. They provide a way to create new types without incurring the runtime overhead of creating additional objects. Inline classes are optimized by the compiler, and the underlying representation is erased at runtime.

Inline classes are used when you want to create distinct types for specific values, adding clarity and type safety to your code.

Here’s an example that demonstrates the usage of inline classes:

inline class Email(val value: String)

fun printEmail(email: Email) {
    println(email.value)
}

fun main() {
    val email = Email("test@example.com")
    printEmail(email) // Output: test@example.com
}

In this example, the Email class is defined as an inline class with a single property value of type String. The printEmail function takes an Email instance as a parameter and prints its value.

Inline classes provide a distinct type (Email) for values that are conceptually different from regular String values. This approach improves type safety and allows you to enforce specific behavior or constraints on those values.

10. How does the ‘@JvmName’ annotation work in Kotlin, and why might you use it?

The @JvmName annotation in Kotlin is used to change the generated Java method name when a Kotlin function is called from Java. It allows you to control the generated Java method name, which can be useful for interoperation with existing Java code or libraries.

Here’s an example that demonstrates the usage of the @JvmName annotation:

@file:JvmName("StringUtil")

package com.example

fun toUpperCase(text: String): String {
    return text.toUpperCase()
}

In this example, the @JvmName annotation is used to change the generated Java class name from StringUtilKt (default) to StringUtil. This makes it easier to use the function toUpperCase when calling from Java code:

import com.example.StringUtil;

public class Main {
    public static void main(String[] args) {
        String text = "hello";
        String upperCaseText = StringUtil.toUpperCase(text);
        System.out.println(upperCaseText); // Output: HELLO
    }
}

The @JvmName annotation simplifies the interoperation between Kotlin and Java by providing control over the generated method or class names. It is particularly useful when working with existing Java codebases or libraries that rely on specific method names or conventions.

11. How does the ‘equals()’ function in Kotlin differ from the ‘==’ and ‘===’ operators?

In Kotlin, the equals() function and the == and === operators are used for equality comparison, but they differ in terms of behavior and purpose.

1. equals() function: The equals() function is a method defined by the Any class in Kotlin. It is intended for structural equality comparison, where the implementation can be overridden in subclasses. By default, equals() checks for reference equality (===).
2. ‘==’ operator: The == operator is used for structural equality comparison. It is typically used to compare objects for equality, including nullable values. The behavior of == can be customized by overriding the equals() function.
3. ‘===’ operator: The === operator is used for referential equality comparison. It checks whether two references point to the same object in memory.

Here are examples that demonstrate the differences between equals(), ==, and ===:

class Person(val name: String)

fun main() {
    val person1 = Person("John")
    val person2 = Person("John")
    val person3 = person1

    println(person1 == person2) // Output: true
    println(person1 === person2) // Output: false

    println(person1.equals(person2)) // Output: true
    println(person1.equals(person3)) // Output: true
}

In this example, two Person instances (person1 and person2) with the same name “John” are created. When using the == operator, they are considered equal because equals() is called, which performs structural equality comparison. However, === returns false because the references point to different objects.

12. What are Coroutine Context and Dispatchers in Kotlin?

Coroutine Context and Dispatchers are concepts in Kotlin coroutines that define the context in which coroutines run and the dispatching of coroutine tasks to different threads or thread pools.

1. Coroutine Context: Coroutine Context is a set of elements that define the behavior and context of a coroutine, such as its job, dispatcher, and other elements. It can be thought of as an execution environment for coroutines. The Coroutine Context is structured and can be modified using the plus and minus operators.
2. Dispatchers: Dispatchers define the thread or thread pool on which a coroutine will be executed. Kotlin provides several built-in dispatchers, including Dispatchers.Default (uses a shared background pool), Dispatchers.IO (optimized for IO-bound tasks), Dispatchers.Main (for Android UI operations), and more.

Here’s an example that demonstrates the usage of Coroutine Context and Dispatchers:

import kotlinx.coroutines.*

fun main() = runBlocking<Unit> {
    val context: CoroutineContext = Dispatchers.Default // Coroutine context

    launch(context) {
        println("Coroutine 1 running on ${Thread.currentThread().name}")
    }

    launch(Dispatchers.IO) {
        println("Coroutine 2 running on ${Thread.currentThread().name}")
    }

    launch(Dispatchers.Main) {
        println("Coroutine 3 running on ${Thread.currentThread().name}")
    }
}

In this example, coroutines are launched with different dispatchers. The first coroutine uses the context with Dispatchers.Default, the second coroutine uses Dispatchers.IO, and the third coroutine uses Dispatchers.Main. Each coroutine prints the name of the thread it is running on.

13. Explain the difference between Flow and Channel in Kotlin.

14. How do you perform exception handling in Kotlin Coroutines?

Exception handling in Kotlin coroutines is performed using try-catch blocks or catch blocks within the coroutine scope. Exceptions can be caught and handled using standard exception handling techniques.

Here’s an example that demonstrates exception handling in coroutines:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            delay(1000)
            throw Exception("Something went wrong")
        } catch (e: Exception) {
            println("Caught exception: ${e.message}")
        }
    }

    job.join()
}

In this example, a coroutine is launched with a launch builder. Inside the coroutine, a try-catch block is used to catch any exceptions that may occur. After a delay of 1 second, an exception is thrown. The catch block catches the exception and prints the error message.

15. What is Reflection in Kotlin and how do you use it?

Reflection in Kotlin allows you to examine and manipulate program entities (classes, functions, properties) at runtime. It provides the ability to inspect and modify the structure and behavior of code dynamically.

To use reflection in Kotlin, you need to import the kotlin.reflect package. Some commonly used classes and functions for reflection are KClass, KCallable, KProperty, call(), createInstance(), etc.

Here’s an example that demonstrates the usage of reflection:

import kotlin.reflect.full.createInstance
import kotlin.reflect.full.declaredMemberProperties

data class Person(val name: String, val age: Int)

fun main() {
    val personClass = Person::class
    val properties = personClass.declaredMemberProperties

    val person = personClass.createInstance()
    properties.forEach { prop ->
        if (prop.name == "name")

 {
            prop.call(person, "John")
        } else if (prop.name == "age") {
            prop.call(person, 30)
        }
    }

    println(person) // Output: Person(name=John, age=30)
}

In this example, reflection is used to create an instance of the Person class dynamically. The Person::class reference provides access to class-level information. The declaredMemberProperties property retrieves the properties of the class.

Using reflection, the properties are iterated, and their values are set dynamically using the call() function. Finally, the modified person object is printed.

16. What are contracts in Kotlin and what are they used for?

Contracts in Kotlin are a feature introduced in Kotlin 1.3 to improve the type system and provide additional hints to the compiler about the behavior of functions. Contracts are used to provide extra information about the behavior of functions, such as nullability guarantees and type invariants.

Contracts allow you to define preconditions and postconditions for functions and provide hints to the compiler for smart casts and optimizations.

Here’s an example that demonstrates the usage of contracts:

import kotlin.contracts.contract

fun checkNotNull(value: Any?): Boolean {
    contract {
        returns(true) implies (value != null)
    }
    return value != null
}

fun main() {
    val value: String? = "Hello"
    if (checkNotNull(value)) {
        println(value.length) // Smart cast: value is non-null
    }
}

In this example, the checkNotNull function uses a contract to provide additional information to the compiler. The contract states that if the function returns true, the value should be non-null. This allows the compiler to perform a smart cast, treating value as non-null inside the if block.

17. Explain what a ‘backing property’ is in Kotlin.

A backing property in Kotlin is a private field that stores the value of a property. It is accessed through the property’s getter and setter methods. Backing properties provide a mechanism to control access to the property while storing its value internally.

Here’s an example that demonstrates the usage of backing properties:

class Person {
    private var _age: Int = 0

    var age: Int
        get() = _age
        set(value) {
            _age = if (value >= 0) value else 0
        }
}

fun main() {
    val person = Person()
    person.age = 30
    println(person.age) // Output: 30

    person.age = -10
    println(person.age) // Output: 0
}

In this example, the Person class has a private backing property _age that stores the age value. The public age property provides access to the backing property through its getter and setter methods. The setter enforces a non-negative value by assigning 0 if the value is less than 0.

18. What is Kotlin/Native and what are its uses?

Kotlin/Native is a technology from JetBrains that allows you to compile Kotlin code directly to native binaries, without relying on a virtual machine (such as the JVM) or an interpreter. It enables you to build native applications, libraries, or system components using Kotlin.

Some uses of Kotlin/Native include:

1. Cross-platform development: Kotlin/Native allows you to write code once and compile it to native binaries for multiple platforms, such as macOS, iOS, Android, Windows, Linux, etc. This enables sharing code and logic between different platforms.
2. Performance-critical components: Kotlin/Native is useful for building performance-sensitive components where low-level access and efficient memory management are required. It provides interoperability with C and Objective-C, allowing you to reuse existing native libraries and frameworks.
3. Embedded systems: Kotlin/Native is suitable for developing software for embedded systems, IoT devices, or other resource-constrained environments. It allows you to write native code with Kotlin’s expressive and modern language features.

19. How can you ensure thread safety in Kotlin?

To ensure thread safety in Kotlin, you can use several techniques and synchronization mechanisms:

1. Immutable data: Prefer using immutable data structures that cannot be modified once created. Immutable objects are inherently thread-safe, as their state cannot change.
2. Synchronized blocks and methods: Use synchronized blocks or methods to protect shared mutable state. Synchronization ensures that only one thread can access the synchronized block or method at a time, preventing data races.
3. Atomic types: Atomic types, such as AtomicInteger, AtomicBoolean, etc., provide atomic operations on shared variables without explicit locking. They are designed for concurrent access and eliminate the need for explicit synchronization.
4. Thread-safe collections: Kotlin provides thread-safe versions of collections in the java.util.concurrent package, such as ConcurrentHashMap, CopyOnWriteArrayList, etc. These collections are designed for concurrent access and provide thread-safe operations.
5. Locks and conditions: Use explicit locks and conditions from the java.util.concurrent.locks package, such as ReentrantLock, ReadWriteLock, etc., to control access to shared resources. Locks provide more fine-grained control over synchronization compared to synchronized blocks.
6. Concurrency utilities: Utilize higher-level concurrency utilities from the kotlinx.coroutines library, such as channels, actors, and other primitives, to coordinate and communicate between coroutines and ensure thread safety.

20. How can you use extension functions to extend a Java class in Kotlin?

In Kotlin, extension functions allow you to add new functions to existing classes, including Java classes, without modifying their source code. Extension functions provide a way to augment the behavior of classes and provide additional functionality.

Here’s an example that demonstrates the usage of extension functions to extend a Java class:

// Java class
public class MyClass {
    public void doSomething() {
        System.out.println("Doing something");
    }
}

// Kotlin extension function
fun MyClass.extensionFunction() {
    println("Extension function")
}

fun main() {
    val myObject = MyClass()
    myObject.extensionFunction() // Output: Extension function
    myObject.doSomething() // Output: Doing something
}

In this example, the MyClass Java class has a method doSomething(). In Kotlin, an extension function extensionFunction() is defined for the MyClass class. The extension function can be called on instances of MyClass and adds new behavior to the class.

MCQ Questions

1. What is Kotlin?

a) A programming language for building Android apps
b) A statically typed programming language for modern multi-platform applications
c) A scripting language for web development
d) A markup language for building user interfaces

Answer: b) A statically typed programming language for modern multi-platform applications

2. Which of the following is true about Kotlin?

a) Kotlin is a purely functional programming language
b) Kotlin is a dynamically typed language
c) Kotlin is fully interoperable with Java
d) Kotlin is only used for server-side programming

Answer: c) Kotlin is fully interoperable with Java

3. What is the official build system for Kotlin?

a) Maven
b) Gradle
c) Ant
d) Make

Answer: b) Gradle

4. What is the default visibility modifier in Kotlin?

a) private
b) protected
c) internal
d) public

Answer: c) internal

5. Which keyword is used to define a nullable variable in Kotlin?

a) nullable
b) optional
c) var
d) ?

Answer: d) ?

6. In Kotlin, which keyword is used to declare a class?

a) class
b) struct
c) object
d) type

Answer: a) class

7. Which operator is used for safe null navigation in Kotlin?

a) .?
b) ?.
c) !!
d) ??

Answer: b) ?.

8. What does the `lateinit` keyword mean in Kotlin?

a) It indicates that a property can have a null value.
b) It indicates that a property can be assigned a value later.
c) It indicates that a property is read-only.
d) It indicates that a property can be accessed from any module.

Answer: b) It indicates that a property can be assigned a value later.

9. What is the primary constructor in Kotlin?

a) The constructor defined using the constructor keyword.
b) The constructor defined inside a companion object.
c) The constructor defined with default values for parameters.
d) The constructor defined with a single parameter.

Answer: a) The constructor defined using the constructor keyword.

10. What is the correct way to define an extension function in Kotlin?

a) fun String.extensionFunction() { … }
b) fun extensionFunction(String s) { … }
c) String.extensionFunction() { … }
d) fun extensionFunction(s: String) { … }

Answer: a) fun String.extensionFunction() { … }

11. What is the Kotlin equivalent of Java’s `switch` statement?

a) if-else statement
b) when expression
c) case statement
d) match statement

Answer: b) when expression

12. Which function is used to create a range in Kotlin?

a) rangeOf()
b) createRange()
c) until()
d) range()

Answer: d) range()

13. What is the output of the following code snippet?

val x = 5
val y = 2
val result = x / y


println(result)

a) 2
b) 2.5
c) 2.0
d) Compilation error

Answer: a) 2

14. What is the default visibility modifier for properties and functions in Kotlin?

a) public
b) private
c) protected
d) internal

Answer: a) public

15. What is the Kotlin convention for defining getters and setters?

a) Using the get() and set() methods
b) Using the get and set keywords
c) Using the getValue() and setValue() functions
d) Getters and setters are automatically generated

Answer: d) Getters and setters are automatically generated

16. In Kotlin, which collection type guarantees unique elements?

a) List
b) Set
c) Array
d) Map

Answer: b) Set

17. What is the correct way to define a lambda expression in Kotlin?

a) {x, y -> x + y}
b) (x, y) -> x + y
c) lambda x, y: x + y
d) [x, y] => x + y

Answer: a) {x, y -> x + y}

18. What is the purpose of the `also` function in Kotlin?

a) To perform a side effect on an object and return the object itself
b) To filter elements in a collection based on a condition
c) To map elements in a collection to a different type
d) To combine two collections into one

Answer: a) To perform a side effect on an object and return the object itself

19. Which keyword is used to declare a constant in Kotlin?

a) val
b) var
c) const
d) final

Answer: a) val

20. What is the output of the following code snippet?

val x: Any = "Hello"
val y: String? = x as? String
println(y)

a) Hello
b) null
c) ClassCastException
d) Compilation error

Answer: a) Hello

21. In Kotlin, how do you create a new instance of a class?

a) Using the new keyword
b) Using the create keyword
c) Using the class name followed by parentheses
d) Using the newInstance() function

Answer: c) Using the class name followed by parentheses

22. Which of the following is not a valid Kotlin visibility modifier?

a) public
b) protected
c) package-private
d) private

Answer: c) package-private

23. What is the purpose of the `repeat` function in Kotlin?

a) To repeat a string a specific number of times
b) To iterate over a collection
c) To execute a block of code multiple times
d) To generate a sequence of numbers

Answer: c) To execute a block of code multiple times

24. In Kotlin, what is the type of the expression `null`?

a) NullType
b) Any
c) Unit
d) Nothing

Answer: d) Nothing

25. Which keyword is used to define a sealed class in Kotlin?

a) sealed
b) abstract
c) final
d) data

Answer: a) sealed

26. What is the output of the following code snippet?

val a = "hello"
val b = StringBuilder(a)
val c = b.append(" world")
println(a)

a) hello
b) world
c) hello world
d) Compilation error

Answer: a) hello

27. In Kotlin, how do you handle exceptions?

a) Using the try and catch blocks
b) Using the throws keyword
c) Using the throw keyword
d) Kotlin does not have exceptions

Answer: a) Using the try and catch blocks

28. What is the purpose of the `init` block in Kotlin?

a) To define the primary constructor of a class
b) To define properties and functions in a class
c) To initialize properties of a class
d) To define secondary constructors of a class

Answer: c) To initialize properties of a class

29. Which of the following is not a type of function in Kotlin?

a) Regular function
b) Extension function
c) Inline function
d) Infix function

Answer: a) Regular function

30. What is the output of the following code snippet?

val x = "10"
val y = 5
val result = x.toInt() + y
println(result)

a) 15
b) 105
c) 10 + 5
d) Compilation error

Answer: a) 15

31. In Kotlin, what does the `by` keyword indicate in class delegation?

a) It specifies the base class of a derived class
b) It indicates that a class is derived from another class
c) It specifies the property to delegate to in a delegated property
d) It indicates that a class implements an interface by delegation

Answer: d) It indicates that a class implements an interface by delegation

32. What is the output of the following code snippet?

fun main() {
    val list = listOf(1, 2, 3)
    val result = list.map { it * 2 }
    println(result)
}

a) [2, 4, 6]
b) [1, 2, 3, 1, 2, 3]
c) [1, 4, 9]
d) Compilation error

Answer: a) [2, 4, 6]

33. In Kotlin, what is the purpose of the `run` function?

a) To execute a block of code on a nullable object
b) To execute a block of code on a non-null object
c) To create a new thread to execute a block of code
d) To run a coroutine

Answer: b) To execute a block of code on a non-null object

34. What is the output of the following code snippet?

fun printMessage(message: String = "Hello") {
    println(message)
}

printMessage()

a) Hello
b) Compilation error
c) Runtime exception
d) Nothing is printed

Answer: a) Hello

35. In Kotlin, what is the purpose of the `step` function?

a) To skip elements in a collection
b) To iterate over a collection in reverse order
c) To iterate over a range with a specific step size
d) To perform a step in a loop

Answer: c) To iterate over a range with a specific step size

36. What is the output of the following code snippet?

val list = listOf(1, 2, 3, 4, 5)
val result = list.filter { it % 2 == 0 }
println(result)

a) [1, 3, 5]
b) [2, 4]
c) [1, 2, 3, 4, 5]
d) Compilation error

Answer: b) [2, 4]

37. In Kotlin, which scope function is used for safe calling and returning a result?

a) let
b) run
c) also
d) apply

Answer: a) let

38. What is the output of the following code snippet?

fun main() {
    val x: Int? = null
    val y = x ?: 10
    println(y)
}

a) 0
b) 10
c) null
d) Compilation error

Answer: b) 10

39. In Kotlin, what is the purpose of the `tailrec` keyword?

a) It indicates that a function is tail-recursive
b) It specifies the tail of a linked list
c) It indicates that a property can be accessed from the tail of a class hierarchy
d) Kotlin does not have a tailrec keyword

Answer: a) It indicates that a function is tail-recursive

40. What is the output of the following code snippet?

val list = mutableListOf(1, 2, 3)
list.add(4)
list.remove(2)
println(list)

a) [1, 2, 3]
b) [1, 3, 4]
c) [1, 3]
d) Compilation error

Answer: c) [1, 3]