Kotlin Interview Questions

Kotlin provides several key advantages over Java:\n\n1. Null Safety\n• Prevents NullPointerException at compile time\n• Distinguishes between nullable and non-nullable types\n• Example: var name: String = "John" // Cannot be null\n\n2. Concise Syntax\n• Reduces boilerplate code by up to 40%\n• Data classes auto-generate common methods\n• Example: data class User(val name: String, val age: Int)\n\n3. Extension Functions\n• Add functionality to existing classes without inheritance\n• Example: fun String.isPalindrome() = this == this.reversed()\n\n4. Smart Casts\n• Automatic type casting after null checks\n• Example: if (obj is String) { println(obj.length) }\n\n5. Coroutines\n• Built-in support for asynchronous programming\n• Lightweight alternative to threads\n• Example: suspend fun fetchData() { delay(1000) }\n\n6. 100% Java Interoperability\n• Use existing Java libraries seamlessly\n• Gradual migration from Java projects possible

Kotlin uses two keywords for variable declaration:\n\n1. val (Value - Immutable)\n• Read-only reference, cannot be reassigned\n• Similar to final in Java\n• Example:\n\nval name = "John"\n// name = "Jane" // Compilation error\n\n\n2. var (Variable - Mutable)\n• Can be reassigned after initialization\n• Value can change during execution\n• Example:\n\nvar age = 25\nage = 26 // OK\n\n\n3. Important Notes\n• val makes the reference immutable, not the object\n• Example:\n\nval list = mutableListOf(1, 2, 3)\nlist.add(4) // OK - object is mutable\n// list = mutableListOf(5, 6) // Error - reference immutable\n\n\n4. Best Practice\n• Use val by default for immutability\n• Use var only when reassignment is needed\n• Improves code safety and readability

Null safety is Kotlin's system to eliminate NullPointerException at compile time:\n\n1. Non-nullable Types (Default)\n• Variables cannot hold null by default\n• Example: var name: String = "John" // Cannot be null\n\n2. Nullable Types (Explicit)\n• Must explicitly allow null with ?\n• Example: var name: String? = null // Can be null\n\n3. Safe Call Operator (?.)\n• Safely access nullable properties\n• Returns null if receiver is null\n• Example: val length = name?.length\n\n4. Elvis Operator (?:)\n• Provides default value for null cases\n• Example: val length = name?.length ?: 0\n\n5. Not-null Assertion (!!)\n• Forces unwrap (use carefully)\n• Throws exception if null\n• Example: val length = name!!.length\n\n6. Safe Casting (as?)\n• Returns null if cast fails\n• Example: val str = obj as? String\n\n7. Why Important\n• Eliminates most common runtime error\n• Makes null handling explicit\n• Improves code reliability

Kotlin is a statically typed programming language developed by JetBrains that runs on the JVM. Key advantages: 1) Null safety - prevents NullPointerException at compile time, 2) Concise syntax - reduces boilerplate code, 3) 100% Java interoperability, 4) Coroutines for asynchronous programming, 5) Extension functions, 6) Data classes, 7) Smart casts, 8) Functional programming support.

Kotlin eliminates NullPointerException by distinguishing nullable and non-nullable types. Non-nullable: var name: String = "John" (cannot be null), Nullable: var name: String? = null (can be null). Safe call operator: name?.length, Elvis operator: name?.length ?: 0, Not-null assertion: name!!.length (throws exception if null). This prevents runtime crashes from null references.

Kotlin is a statically typed programming language developed by JetBrains that runs on the JVM and is 100% interoperable with Java.\n\n**Main advantages:**\n• **Null Safety**: Prevents NullPointerException at compile time\n• **Concise Syntax**: Reduces boilerplate code significantly\n• **Extension Functions**: Add functionality to existing classes\n• **Smart Casts**: Automatic type casting after null checks\n• **Data Classes**: Auto-generation of equals, hashCode, toString\n• **Coroutines**: Built-in asynchronous programming support\n• **Type Inference**: Compiler infers types automatically\n\n**Example:**\n\ndata class Person(val name: String, val age: Int?)\nfun greet(person: Person?) {\n person?.let { println("Hello, ${it.name}!") }\n}\n

Kotlin uses two keywords for variable declaration:\n\n1. val (Value - Immutable)\n• Read-only reference, cannot be reassigned\n• Similar to final in Java\n• Example:\n\nval name = "John"\n// name = "Jane" // Compilation error\n\n\n2. var (Variable - Mutable)\n• Can be reassigned after initialization\n• Value can change during execution\n• Example:\n\nvar age = 25\nage = 26 // OK\n\n\n3. Important Notes\n• val makes the reference immutable, not the object\n• Example:\n\nval list = mutableListOf(1, 2, 3)\nlist.add(4) // OK - object is mutable\n// list = mutableListOf(5, 6) // Error - reference immutable\n\n\n4. Best Practice\n• Use val by default for immutability\n• Use var only when reassignment is needed\n• Improves code safety and readability

Sealed classes restrict inheritance hierarchy to a known set of subclasses:\n\n1. Declaration\n• All subclasses must be in the same file\n• Provides exhaustive when expressions\n• Example:\n\n\n2. Exhaustive When Expressions\n• Compiler ensures all cases are handled\n• No else clause needed\n• Example:\n\n\n3. Advanced Usage with Generics\n\n\n4. Benefits\n• Type safety with exhaustive checking\n• Better than enums for complex data\n• Compiler prevents missing cases\n• Clear state representation\n\n5. Common Use Cases\n• API response states\n• UI state management\n• Navigation states\n• Result handling patterns

Scope functions execute code blocks within object context with different return values and context references.\n\n**let** - Returns lambda result, context as "it":\n\nval result = person?.let {\n println("Name: ${it.name}")\n it.age * 2\n} // Returns age * 2 or null\n\n// Use case: null safety and transformations\nval length = text?.let { it.trim().length }\n\n\n**run** - Returns lambda result, context as "this":\n\nval result = person.run {\n println("Name: $name") // direct access\n age * 2\n} // Returns age * 2\n\n// Use case: object configuration and computation\nval result = service.run {\n configure()\n execute()\n}\n\n\n**apply** - Returns context object, context as "this":\n\nval person = Person().apply {\n name = "John"\n age = 30\n email = "john@example.com"\n} // Returns configured Person object\n\n// Use case: object initialization\nval intent = Intent().apply {\n action = Intent.ACTION_VIEW\n data = Uri.parse(url)\n}\n\n\n**also** - Returns context object, context as "it":\n\nval person = Person("John", 30).also {\n println("Created person: ${it.name}")\n logger.log("Person created")\n} // Returns original Person object\n\n// Use case: additional actions without changing object\n\n\n**with** - Non-extension function, returns lambda result:\n\nval result = with(person) {\n println("Name: $name")\n age * 2\n} // Returns age * 2\n\n// Use case: multiple operations on object\nwith(canvas) {\n drawCircle(x, y, radius)\n drawText(text, x, y)\n}\n\n\n**Selection guide:**\n• **let**: null safety, transformations\n• **run**: object configuration + computation\n• **apply**: object initialization\n• **also**: additional actions, logging\n• **with**: multiple operations on non-null object

Higher-order functions and lambdas enable functional programming in Kotlin:\n\n1. Higher-order Functions\n• Functions that take functions as parameters\n• Functions that return other functions\n• Enable powerful abstractions and reusable code\n\n2. Lambda Expressions\n• Anonymous functions with concise syntax\n• Can be passed as arguments\n• Example:\n\nval sum = { a: Int, b: Int -> a + b }\nval square: (Int) -> Int = { it * it }\n\n\n3. Function Types\n\n// Function type declarations\nval operation: (Int, Int) -> Int = { a, b -> a + b }\nval predicate: (String) -> Boolean = { it.isNotEmpty() }\n\n\n4. Higher-order Function Examples\n\nfun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {\n return operation(x, y)\n}\n\n// Usage\nval result = calculate(5, 3) { a, b -> a * b } // 15\n\n\n5. Collection Operations\n\nval numbers = listOf(1, 2, 3, 4, 5)\n\nval doubled = numbers.map { it * 2 }\nval evens = numbers.filter { it % 2 == 0 }\nval sum = numbers.reduce { acc, n -> acc + n }\n\n// Chaining operations\nval result = numbers\n .filter { it > 2 }\n .map { it * it }\n .sum()\n\n\n6. Trailing Lambda Syntax\n\n// When lambda is last parameter\nrepeat(3) {\n println("Hello")\n}\n\n// Instead of\nrepeat(3, { println("Hello") })\n\n\n7. Benefits\n• Code reusability and modularity\n• Functional programming patterns\n• Cleaner API design\n• Better abstraction capabilities

Kotlin distinguishes between mutable and immutable collections at the type level.\n\n**Immutable collections (read-only):**\n\nval list: List = listOf("a", "b", "c")\nval set: Set = setOf(1, 2, 3)\nval map: Map = mapOf("a" to 1, "b" to 2)\n\n// list.add("d") // Compilation error\n\n\n**Mutable collections:**\n\nval mutableList: MutableList = mutableListOf("a", "b")\nval mutableSet: MutableSet = mutableSetOf(1, 2)\nval mutableMap: MutableMap = mutableMapOf("a" to 1)\n\nmutableList.add("c") // OK\nmutableSet.remove(1) // OK\nmutableMap["b"] = 2 // OK\n\n\n**Collection operations:**\n\nval numbers = listOf(1, 2, 3, 4, 5)\n\n// Transformations (return new collections)\nval doubled = numbers.map { it * 2 }\nval filtered = numbers.filter { it > 2 }\nval sorted = numbers.sortedDescending()\n\n// Aggregations\nval sum = numbers.sum()\nval max = numbers.maxOrNull()\nval any = numbers.any { it > 3 }\nval all = numbers.all { it > 0 }\n\n// Grouping\nval grouped = numbers.groupBy { it % 2 == 0 }\n// {false=[1, 3, 5], true=[2, 4]}\n\n\n**Sequences for lazy evaluation:**\n\nval result = (1..1000000)\n .asSequence()\n .filter { it % 2 == 0 }\n .map { it * it }\n .take(10)\n .toList()\n\n\n**Array vs List:**\n\nval array = arrayOf(1, 2, 3) // Fixed size, mutable elements\nval list = listOf(1, 2, 3) // Immutable\nval mutableList = mutableListOf(1, 2, 3) // Mutable\n

Object declarations create singletons, while companion objects provide class-level functionality.\n\n**Object declaration (Singleton):**\n\nobject DatabaseManager {\n private var connection: Connection? = null\n \n fun connect() {\n connection = DriverManager.getConnection(url)\n }\n \n fun query(sql: String): ResultSet? {\n return connection?.createStatement()?.executeQuery(sql)\n }\n}\n\n// Usage\nDatabaseManager.connect()\nval results = DatabaseManager.query("SELECT * FROM users")\n\n\n**Companion object:**\n\nclass User(val name: String, val email: String) {\n companion object {\n const val MIN_AGE = 18\n private var userCount = 0\n \n fun create(name: String, email: String): User {\n userCount++\n return User(name, email)\n }\n \n fun getUserCount() = userCount\n }\n}\n\n// Usage\nval user = User.create("John", "john@email.com")\nprintln(User.MIN_AGE)\nprintln(User.getUserCount())\n\n\n**Companion object with interface:**\n\ninterface Factory {\n fun create(): T\n}\n\nclass MyClass {\n companion object : Factory {\n override fun create(): MyClass = MyClass()\n }\n}\n\n\n**Object expressions (anonymous objects):**\n\nval clickListener = object : View.OnClickListener {\n override fun onClick(v: View?) {\n println("Clicked!")\n }\n}\n\n// With multiple interfaces\nval handler = object : Runnable, Serializable {\n override fun run() {\n println("Running")\n }\n}\n\n\n**Key differences:**\n• **object**: Creates singleton instance\n• **companion object**: One per class, accessible via class name\n• **object expression**: Anonymous object for interfaces/abstract classes

Generics provide type safety while maintaining flexibility. Variance controls subtyping relationships.\n\n**Basic generics:**\n\nclass Box(val value: T)\n\nfun identity(value: T): T = value\n\nval stringBox = Box("Hello")\nval intBox = Box(42)\n\n\n**Variance:**\n\n**Covariance (out) - Producer:**\n\ninterface Producer {\n fun produce(): T // Only produces T, never consumes\n}\n\nval stringProducer: Producer = object : Producer {\n override fun produce() = "Hello"\n}\nval anyProducer: Producer = stringProducer // OK - covariant\n\n\n**Contravariance (in) - Consumer:**\n\ninterface Consumer {\n fun consume(item: T) // Only consumes T, never produces\n}\n\nval anyConsumer: Consumer = object : Consumer {\n override fun consume(item: Any) = println(item)\n}\nval stringConsumer: Consumer = anyConsumer // OK - contravariant\n\n\n**Use-site variance:**\n\nfun copy(from: Array, to: Array) {\n for (i in from.indices) {\n to[i] = from[i]\n }\n}\n\n\n**Reified types (inline functions only):**\n\ninline fun isInstance(value: Any): Boolean {\n return value is T // T available at runtime\n}\n\ninline fun Gson.fromJson(json: String): T {\n return fromJson(json, T::class.java)\n}\n\n// Usage\nval isString = isInstance("Hello") // true\nval user = gson.fromJson(jsonString)\n\n\n**Type constraints:**\n\nfun > sort(list: List): List {\n return list.sorted()\n}\n\nfun cloneWhenGreater(list: List, threshold: T): List\n where T : Comparable, T : Cloneable {\n return list.filter { it > threshold }\n}\n\n\n**Star projection:**\n\nfun printList(list: List<*>) { // List\n for (item in list) {\n println(item)\n }\n}\n

Kotlin delegates implement the delegation pattern for properties and classes:\n\n1. Property Delegates\n• Delegate property access to another object\n• Reusable property behavior\n• Built-in delegates available\n\n2. Lazy Delegate\n\n\n3. Observable Delegate\n\n\n4. Custom Delegate\n\n\n5. Class Delegation\n\n\n6. Map Delegate\n\n\n7. Benefits\n• Code reuse and composition\n• Separation of concerns\n• Cleaner property implementations\n• Built-in common patterns

When expressions are Kotlin's powerful replacement for Java's switch statements:\n\n1. Basic When Expression\n\nfun describe(x: Any) = when (x) {\n 1 -> "One"\n "Hello" -> "Greeting"\n is Long -> "Long number"\n !is String -> "Not a string"\n else -> "Unknown"\n}\n\n\n2. When as Statement vs Expression\n\n// As statement\nwhen (x) {\n 1 -> println("One")\n 2 -> println("Two")\n}\n\n// As expression (must be exhaustive)\nval result = when (x) {\n 1 -> "One"\n 2 -> "Two"\n else -> "Other"\n}\n\n\n3. Multiple Conditions\n\nwhen (x) {\n 0, 1 -> println("Small number")\n in 2..10 -> println("Medium number")\n in validNumbers -> println("Valid")\n !in 0..100 -> println("Out of range")\n}\n\n\n4. Smart Casting\n\nfun process(obj: Any) = when (obj) {\n is String -> obj.length // obj automatically cast to String\n is IntArray -> obj.sum() // obj automatically cast to IntArray\n is List<*> -> obj.size\n else -> 0\n}\n\n\n5. Exhaustive with Sealed Classes\n\nsealed class Result\nclass Success(val data: String) : Result()\nclass Error(val message: String) : Result()\n\nfun handle(result: Result) = when (result) {\n is Success -> "Data: ${result.data}"\n is Error -> "Error: ${result.message}"\n // No else needed - compiler ensures exhaustiveness\n}\n\n\n6. Capturing When Subject\n\nwhen (val trimmed = input?.trim()) {\n null -> println("Input is null")\n "" -> println("Input is empty")\n else -> println("Input: $trimmed")\n}\n\n\n7. Advantages over Switch\n• Returns values (expression)\n• Pattern matching with type checking\n• Smart casting\n• Range and collection checks\n• No fall-through (safer)\n• Exhaustiveness checking

Value classes (formerly inline classes) provide type safety without runtime overhead:\n\n1. Declaration\n• Wrap primitive types for type safety\n• No runtime object creation\n• Example:\n\n@JvmInline\nvalue class UserId(val value: Int)\n\n@JvmInline\nvalue class Email(val value: String)\n\n\n2. Type Safety Benefits\n\nfun createUser(id: UserId, email: Email) {\n // Implementation\n}\n\n// Compile-time safety\nval userId = UserId(123)\nval email = Email("user@example.com")\n\ncreateUser(userId, email) // OK\n// createUser(email, userId) // Compilation error\n\n\n3. No Runtime Overhead\n\n// At runtime, this:\nval userId = UserId(123)\nval id = userId.value\n\n// Becomes this (no wrapper object):\nval id = 123\n\n\n4. Methods and Properties\n\n@JvmInline\nvalue class Distance(val meters: Double) {\n val kilometers: Double get() = meters / 1000\n val miles: Double get() = meters * 0.000621371\n \n operator fun plus(other: Distance) = Distance(meters + other.meters)\n operator fun compareTo(other: Distance) = meters.compareTo(other.meters)\n}\n\nval d1 = Distance(1000.0)\nval d2 = Distance(500.0)\nval total = d1 + d2\nprintln(total.kilometers) // 1.5\n\n\n5. Interface Implementation\n\ninterface Printable {\n fun print()\n}\n\n@JvmInline\nvalue class Name(val value: String) : Printable {\n override fun print() {\n println("Name: $value")\n }\n}\n\n\n6. Restrictions\n• Must have exactly one property in primary constructor\n• Property must be val\n• Cannot have init blocks\n• Cannot have backing fields\n• Cannot extend classes (can implement interfaces)\n\n7. Use Cases\n• Type-safe APIs (IDs, measurements)\n• Domain modeling without performance cost\n• Preventing parameter mix-ups\n• Adding behavior to primitive types

Operator overloading allows defining custom behavior for operators on user-defined types using specific function names.\n\n**Arithmetic operators:**\n\ndata class Point(val x: Int, val y: Int) {\n operator fun plus(other: Point) = Point(x + other.x, y + other.y)\n operator fun minus(other: Point) = Point(x - other.x, y - other.y)\n operator fun times(scalar: Int) = Point(x * scalar, y * scalar)\n operator fun div(scalar: Int) = Point(x / scalar, y / scalar)\n operator fun unaryMinus() = Point(-x, -y)\n}\n\nval p1 = Point(1, 2)\nval p2 = Point(3, 4)\nval sum = p1 + p2 // Point(4, 6)\nval scaled = p1 * 3 // Point(3, 6)\nval negated = -p1 // Point(-1, -2)\n\n\n**Comparison operators:**\n\ndata class Version(val major: Int, val minor: Int, val patch: Int) : Comparable {\n override fun compareTo(other: Version): Int {\n return when {\n major != other.major -> major - other.major\n minor != other.minor -> minor - other.minor\n else -> patch - other.patch\n }\n }\n}\n\nval v1 = Version(1, 2, 3)\nval v2 = Version(1, 3, 0)\nprintln(v1 < v2) // true\nprintln(v1 >= v2) // false\n\n\n**Index access operators:**\n\nclass Matrix(private val data: Array) {\n operator fun get(row: Int, col: Int): Int {\n return data[row][col]\n }\n \n operator fun set(row: Int, col: Int, value: Int) {\n data[row][col] = value\n }\n}\n\nval matrix = Matrix(arrayOf(intArrayOf(1, 2), intArrayOf(3, 4)))\nval value = matrix[0, 1] // 2\nmatrix[1, 0] = 5\n\n\n**Invoke operator (function call):**\n\nclass Multiplier(val factor: Int) {\n operator fun invoke(value: Int): Int {\n return value * factor\n }\n}\n\nval double = Multiplier(2)\nval result = double(5) // 10 (calls invoke)\n\n\n**Contains operator:**\n\nclass Range(val start: Int, val end: Int) {\n operator fun contains(value: Int): Boolean {\n return value in start..end\n }\n}\n\nval range = Range(1, 10)\nprintln(5 in range) // true\nprintln(15 in range) // false\n\n\n**Iterator operators:**\n\nclass CountDown(val start: Int) {\n operator fun iterator() = object : Iterator {\n private var current = start\n \n override fun hasNext() = current > 0\n override fun next() = current--\n }\n}\n\nfor (i in CountDown(3)) {\n println(i) // 3, 2, 1\n}\n\n\n**Destructuring operators:**\n\ndata class Person(val name: String, val age: Int, val email: String) {\n operator fun component1() = name\n operator fun component2() = age\n operator fun component3() = email\n}\n\nval person = Person("John", 30, "john@email.com")\nval (name, age, email) = person // Destructuring\n\n\n**Augmented assignment:**\n\nclass MutablePoint(var x: Int, var y: Int) {\n operator fun plusAssign(other: MutablePoint) {\n x += other.x\n y += other.y\n }\n}\n\nval point = MutablePoint(1, 2)\npoint += MutablePoint(3, 4) // point is now (4, 6)\n\n\n**Operator precedence follows standard mathematical rules:**\n• Unary operators: +, -, !, ++, --\n• Multiplicative: *, /, %\n• Additive: +, -\n• Range: ..\n• Comparison: <, >, <=, >=\n• Equality: ==, !=\n• Logical: &&, ||

Type aliases create alternative names for existing types, improving code readability and maintainability.\n\n**Basic type aliases:**\n\ntypealias UserId = Int\ntypealias UserName = String\ntypealias EmailAddress = String\n\nfun createUser(id: UserId, name: UserName, email: EmailAddress) {\n // Implementation\n}\n\n// Usage\nval userId: UserId = 123\nval userName: UserName = "John Doe"\nval email: EmailAddress = "john@example.com"\n\n\n**Function type aliases:**\n\ntypealias EventHandler = (String) -> Unit\ntypealias Predicate = (T) -> Boolean\ntypealias Transformer = (T) -> R\n\nclass EventManager {\n private val handlers = mutableListOf()\n \n fun addHandler(handler: EventHandler) {\n handlers.add(handler)\n }\n \n fun fireEvent(event: String) {\n handlers.forEach { it(event) }\n }\n}\n\n// Usage\nval logger: EventHandler = { event -> println("Log: $event") }\nval emailer: EventHandler = { event -> sendEmail(event) }\n\n\n**Generic type aliases:**\n\ntypealias StringMap = Map\ntypealias MutableStringMap = MutableMap\ntypealias NodeList = List>\n\n// Usage\nval userPreferences: StringMap = mapOf(\n "theme" to "dark",\n "language" to "en"\n)\n\nval cache: MutableStringMap = mutableMapOf()\n\n\n**Complex type aliases:**\n\ntypealias ApiResponse = Result\ntypealias ValidationResult = Either, ValidatedData>\ntypealias DatabaseConnection = Connection\n\n// Nested generics\ntypealias UserRepository = Repository\ntypealias AsyncResult = CompletableFuture>\n\n\n**Class and interface aliases:**\n\ntypealias MyList = ArrayList\ntypealias StringProcessor = Function\n\nclass DataProcessor {\n private val items: MyList = MyList()\n private val processor: StringProcessor = { it.uppercase() }\n}\n\n\n**When to use type aliases:**\n\n**✅ Good use cases:**\n• Simplifying complex generic types\n• Creating domain-specific names for primitive types\n• Shortening frequently used function types\n• Improving API readability\n• Reducing repetition in type declarations\n\n**❌ Avoid when:**\n• You need type safety (use value classes instead)\n• The alias doesn't add clarity\n• It's used only once or twice\n• It makes code less clear\n\n**Type aliases vs Value classes:**\n\n// Type alias - no runtime type safety\ntypealias UserId = Int\nfun getUser(id: UserId): User = TODO()\nfun getOrder(id: Int): Order = TODO()\n\nval userId: UserId = 123\ngetOrder(userId) // Compiles but wrong!\n\n// Value class - runtime type safety\n@JvmInline\nvalue class UserId(val value: Int)\n\nval userId = UserId(123)\n// getOrder(userId) // Compilation error!\n\n\n**Nested type aliases:**\n\nclass OuterClass {\n typealias InnerAlias = String\n \n fun process(value: InnerAlias) {\n println(value)\n }\n}\n\n// Access nested alias\ntypealias GlobalInnerAlias = OuterClass.InnerAlias\n\n\n**Import aliases:**\n\nimport com.example.ui.Button as UiButton\nimport com.example.data.Button as DataButton\n\n// Now can use both without conflict\nval uiButton = UiButton()\nval dataButton = DataButton()\n

Kotlin coroutines provide asynchronous programming without blocking threads:\n\n1. Suspend Functions\n• Functions that can be paused and resumed\n• Do not block the calling thread\n• Example:\n\n\n2. Coroutine Builders\n• launch - fire and forget, returns Job\n• async - returns Deferred for results\n• runBlocking - blocks current thread\n\n3. Dispatchers\n• Dispatchers.Main - UI thread operations\n• Dispatchers.IO - I/O operations (network, files)\n• Dispatchers.Default - CPU-intensive tasks\n• Dispatchers.Unconfined - not confined to specific thread\n\n4. Example Usage\n\n\n5. Benefits\n• Lightweight - can create millions of coroutines\n• Structured concurrency prevents memory leaks\n• Built-in cancellation support\n• Exception handling\n• Sequential-looking asynchronous code

Inline functions copy function body to call site, eliminating overhead and enabling reified type parameters.\n\n**Basic inline functions:**\n\ninline fun measureTime(block: () -> Unit) {\n val start = System.currentTimeMillis()\n block()\n val end = System.currentTimeMillis()\n println("Time taken: ${end - start}ms")\n}\n\n// Usage - block() call is inlined\nmeasureTime {\n Thread.sleep(1000)\n}\n\n// Compiled equivalent:\nval start = System.currentTimeMillis()\nThread.sleep(1000)\nval end = System.currentTimeMillis()\nprintln("Time taken: ${end - start}ms")\n\n\n**Reified type parameters:**\n\n// Without reified - type erasure\nfun isInstance(value: Any, clazz: Class): Boolean {\n return clazz.isInstance(value)\n}\n\n// With reified - type available at runtime\ninline fun isInstance(value: Any): Boolean {\n return value is T\n}\n\n// Usage\nval isString = isInstance("Hello") // true\nval isInt = isInstance("Hello") // false\n\n\n**Practical reified examples:**\n\n// JSON parsing\ninline fun Gson.fromJson(json: String): T {\n return fromJson(json, T::class.java)\n}\n\nval user = gson.fromJson(jsonString)\n\n// Type-safe casting\ninline fun Any?.safeCast(): T? {\n return this as? T\n}\n\nval string = obj.safeCast()\n\n// Collection filtering\ninline fun List<*>.filterIsInstance(): List {\n return filter { it is T }.map { it as T }\n}\n\nval strings = mixedList.filterIsInstance()\n\n\n**noinline and crossinline:**\n\ninline fun processData(\n data: String,\n noinline logger: (String) -> Unit, // Not inlined\n crossinline processor: (String) -> String // Inlined but no non-local returns\n) {\n logger("Processing: $data")\n \n val result = processor(data)\n \n // Can store noinline lambda in variable\n val storedLogger = logger\n \n // Cannot store crossinline lambda that allows returns\n // val storedProcessor = processor // Would cause compilation error if processor had returns\n}\n\n\n**Non-local returns:**\n\nfun processItems(items: List) {\n items.forEach { item ->\n if (item.isEmpty()) {\n return // Returns from processItems, not forEach\n }\n println(item)\n }\n println("Processing complete")\n}\n\n// With crossinline - prevents non-local returns\ninline fun List.forEachSafe(crossinline action: (T) -> Unit) {\n for (item in this) {\n action(item) // Cannot return from calling function\n }\n}\n\n\n**Performance implications:**\n\n**Benefits:**\n• Eliminates function call overhead\n• Reduces object allocations for lambdas\n• Enables reified generics\n• Better optimization opportunities\n• No boxing/unboxing for primitive parameters\n\n**Costs:**\n• Increases bytecode size (code duplication)\n• Longer compilation time\n• Can cause method size limits in extreme cases\n\n**Performance measurement:**\n\n// Regular function\nfun regularMap(list: List, transform: (T) -> R): List {\n val result = mutableListOf()\n for (item in list) {\n result.add(transform(item))\n }\n return result\n}\n\n// Inline function\ninline fun inlineMap(list: List, transform: (T) -> R): List {\n val result = mutableListOf()\n for (item in list) {\n result.add(transform(item))\n }\n return result\n}\n\n// Benchmark shows inline version is faster for simple operations\nval numbers = (1..1000000).toList()\n\nmeasureTime {\n regularMap(numbers) { it * 2 } // Creates lambda object\n}\n\nmeasureTime {\n inlineMap(numbers) { it * 2 } // No lambda object, inlined multiplication\n}\n\n\n**When to use inline:**\n• Functions with lambda parameters\n• Small, frequently called functions\n• When you need reified generics\n• Performance-critical code paths\n\n**When to avoid inline:**\n• Large functions (increases bytecode size)\n• Functions with complex logic\n• Recursive functions (not allowed)\n• When function is rarely called

Kotlin Multiplatform allows sharing code across platforms using expect/actual declarations for platform-specific implementations.\n\n**Project structure:**\n\nsrc/\n├── commonMain/kotlin/ # Shared code\n├── androidMain/kotlin/ # Android-specific\n├── iosMain/kotlin/ # iOS-specific\n├── jvmMain/kotlin/ # JVM-specific\n└── jsMain/kotlin/ # JavaScript-specific\n\n\n**Expect declarations (common module):**\n\n// commonMain/Platform.kt\nexpect class Platform() {\n val name: String\n val version: String\n}\n\nexpect fun getCurrentTimeMillis(): Long\n\nexpect object Logger {\n fun log(message: String)\n fun error(message: String, throwable: Throwable?)\n}\n\nexpected class DatabaseDriver {\n expect fun connect(url: String)\n expect fun query(sql: String): List>\n expect fun close()\n}\n\n\n**Actual implementations:**\n\n**Android:**\n\n// androidMain/Platform.kt\nactual class Platform actual constructor() {\n actual val name: String = "Android"\n actual val version: String = "${Build.VERSION.SDK_INT}"\n}\n\nactual fun getCurrentTimeMillis(): Long = System.currentTimeMillis()\n\nactual object Logger {\n actual fun log(message: String) {\n Log.d("KMP", message)\n }\n \n actual fun error(message: String, throwable: Throwable?) {\n Log.e("KMP", message, throwable)\n }\n}\n\nactual class DatabaseDriver {\n private var database: SQLiteDatabase? = null\n \n actual fun connect(url: String) {\n database = SQLiteDatabase.openDatabase(url, null, SQLiteDatabase.OPEN_READWRITE)\n }\n \n actual fun query(sql: String): List> {\n // SQLite implementation\n return emptyList()\n }\n \n actual fun close() {\n database?.close()\n }\n}\n\n\n**iOS:**\n\n// iosMain/Platform.kt\nimport platform.UIKit.UIDevice\nimport platform.Foundation.NSDate\n\nactual class Platform actual constructor() {\n actual val name: String = UIDevice.currentDevice.systemName\n actual val version: String = UIDevice.currentDevice.systemVersion\n}\n\nactual fun getCurrentTimeMillis(): Long {\n return (NSDate().timeIntervalSince1970 * 1000).toLong()\n}\n\nactual object Logger {\n actual fun log(message: String) {\n println("iOS Log: $message")\n }\n \n actual fun error(message: String, throwable: Throwable?) {\n println("iOS Error: $message")\n throwable?.printStackTrace()\n }\n}\n\nactual class DatabaseDriver {\n actual fun connect(url: String) {\n // Core Data or SQLite.swift implementation\n }\n \n actual fun query(sql: String): List> {\n // iOS-specific database query\n return emptyList()\n }\n \n actual fun close() {\n // Close iOS database connection\n }\n}\n\n\n**JVM:**\n\n// jvmMain/Platform.kt\nactual class Platform actual constructor() {\n actual val name: String = "JVM"\n actual val version: String = System.getProperty("java.version")\n}\n\nactual fun getCurrentTimeMillis(): Long = System.currentTimeMillis()\n\nactual object Logger {\n actual fun log(message: String) {\n println("JVM Log: $message")\n }\n \n actual fun error(message: String, throwable: Throwable?) {\n System.err.println("JVM Error: $message")\n throwable?.printStackTrace()\n }\n}\n\nactual class DatabaseDriver {\n private var connection: java.sql.Connection? = null\n \n actual fun connect(url: String) {\n connection = java.sql.DriverManager.getConnection(url)\n }\n \n actual fun query(sql: String): List> {\n // JDBC implementation\n return emptyList()\n }\n \n actual fun close() {\n connection?.close()\n }\n}\n\n\n**Shared business logic:**\n\n// commonMain/UserRepository.kt\nclass UserRepository {\n private val database = DatabaseDriver()\n private val platform = Platform()\n \n suspend fun getUsers(): List {\n Logger.log("Fetching users on ${platform.name}")\n \n return try {\n database.connect("users.db")\n val results = database.query("SELECT * FROM users")\n results.map { row ->\n User(\n id = row["id"] as Int,\n name = row["name"] as String,\n email = row["email"] as String\n )\n }\n } catch (e: Exception) {\n Logger.error("Failed to fetch users", e)\n emptyList()\n } finally {\n database.close()\n }\n }\n \n fun getCurrentTimestamp(): Long {\n return getCurrentTimeMillis()\n }\n}\n\n\n**Gradle configuration:**\n\n// build.gradle.kts\nkotlin {\n android()\n ios()\n jvm()\n js(BOTH) {\n browser()\n nodejs()\n }\n \n sourceSets {\n val commonMain by getting {\n dependencies {\n implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")\n implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1")\n }\n }\n \n val androidMain by getting {\n dependencies {\n implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2")\n }\n }\n \n val iosMain by getting {\n dependencies {\n // iOS-specific dependencies\n }\n }\n }\n}\n\n\n**Benefits:**\n• Share business logic across platforms\n• Platform-specific optimizations\n• Type-safe expect/actual contracts\n• Gradual adoption possible\n• Reduced code duplication\n• Consistent API across platforms\n\n**Use cases:**\n• Mobile apps (Android/iOS)\n• Cross-platform libraries\n• Server and client sharing models\n• Desktop applications\n• Web applications\n\n**Limitations:**\n• Platform-specific APIs require expect/actual\n• Build complexity increases\n• Debugging can be challenging\n• Not all Kotlin features available on all platforms\n• Learning curve for platform-specific implementations

Kotlin coroutines provide asynchronous programming without blocking threads. Suspend functions can be paused and resumed without blocking the thread. Key dispatchers include Dispatchers.Main for UI, Dispatchers.IO for I/O operations, and Dispatchers.Default for CPU-intensive tasks. Coroutines are lightweight, support structured concurrency, and provide better exception handling than traditional threading.

Inline functions copy the function body to the call site, eliminating function call overhead. Reified generics allow access to type information at runtime in inline functions. Performance benefits include reduced object allocations and better compiler optimization. However, they increase bytecode size and cannot be recursive.

Kotlin Multiplatform enables code sharing across platforms using expect/actual declarations. Common code defines expected APIs, while platform-specific modules provide actual implementations. This allows sharing business logic while maintaining platform-specific optimizations for Android, iOS, JVM, and JavaScript targets.

Sealed classes restrict inheritance to a known set of subclasses defined in the same file. They enable exhaustive when expressions without else clauses. Perfect for representing restricted hierarchies like API responses, UI states, or navigation states with compile-time safety.

Kotlin delegates implement the delegation pattern for properties and classes. Built-in delegates include lazy initialization, observable properties, and map delegation. Custom delegates use getValue/setValue operators. Class delegation allows implementing interfaces by delegating to another object.

Kotlin null safety prevents NullPointerException at compile time by distinguishing nullable and non-nullable types. Safe call operator (?.) chains operations safely, Elvis operator (?:) provides default values, and not-null assertion (!!) forces unwrapping. This eliminates one of the most common runtime errors.

Kotlin collections distinguish between mutable and immutable types at compile time. Immutable collections (List, Set, Map) are read-only, while mutable versions (MutableList, MutableSet, MutableMap) allow modifications. Rich extension functions provide functional programming operations like map, filter, and reduce.

Kotlin generics support variance with covariance (out) for producers and contravariance (in) for consumers. Type projections enable use-site variance. Reified generics in inline functions provide runtime type access. Star projections handle unknown types safely.

Higher-order functions take functions as parameters or return functions. They enable functional programming patterns, cleaner APIs, and code reusability. Collection operations like map, filter, and reduce are common examples. Lambda expressions provide concise anonymous function syntax.

Object declarations create thread-safe singletons. Companion objects provide class-level functionality similar to static members in Java. Object expressions create anonymous implementations of interfaces. Each serves different purposes in Kotlin object-oriented design.

Migrating from Java to Kotlin can be done incrementally with these proven strategies:\n\n1. Automated Conversion\n• Use IntelliJ IDEA's built-in Java to Kotlin converter\n• Convert entire files or selected code blocks\n• Example conversion:\n\n\n\n2. Gradual Migration Strategy\n• Start with new features in Kotlin\n• Convert utility classes first\n• Migrate data classes and POJOs\n• Convert business logic incrementally\n• Update tests to Kotlin last\n\n3. Interoperability Considerations\n\n\n4. Handling Nullability\n\n\n5. Migration Best Practices\n• Keep Java and Kotlin code side by side during transition\n• Use @JvmStatic for static method compatibility\n• Apply @JvmOverloads for default parameters\n• Handle platform types carefully\n• Refactor to idiomatic Kotlin after conversion\n\n6. Common Migration Steps\n• Phase 1: New features in Kotlin\n• Phase 2: Convert data models\n• Phase 3: Migrate utility functions\n• Phase 4: Convert business logic\n• Phase 5: Refactor to idiomatic Kotlin\n• Phase 6: Remove Java interop annotations

When expressions replace switch statements with more power and safety. Support pattern matching, smart casting, and exhaustive checking with sealed classes. Can be used as statements or expressions. Multiple conditions, ranges, and type checks are supported.

Data classes automatically generate equals, hashCode, toString, copy, and componentN methods for destructuring. Reduce boilerplate code significantly while providing immutability by default. Requirements include primary constructor parameters and specific class modifiers.

Kotlin exception handling is similar to Java but without checked exceptions. Try blocks can be expressions returning values. Coroutines provide structured exception handling. Result types offer functional error handling alternatives to traditional try-catch.

Kotlin type system includes null safety, smart casts, and type inference. Smart casts automatically cast types after successful checks. Platform types handle Java interoperability. Type aliases improve code readability without runtime overhead.

Kotlin offers significant improvements over Java while maintaining full interoperability:\n\n**🔒 Null Safety**\n\n\n**✂️ Concise Syntax**\n\n\n**🔧 Extension Functions**\n\n\n**🎯 Smart Casts**\n\n\n**⚡ Coroutines vs Threads**\n\n\n**🏆 Why Choose Kotlin:**\n• **100% Java Interoperability** - Use existing Java libraries seamlessly\n• **Reduced Boilerplate** - Up to 40% less code than Java\n• **Modern Language Features** - Functional programming, type inference\n• **Google's Preferred** - First-class support for Android development\n• **Multiplatform** - Share code between Android, iOS, Web, Desktop\n• **Growing Ecosystem** - Strong community and library support\n• **Easy Migration** - Gradual conversion from Java projects\n• **Better Developer Experience** - Enhanced IDE support and tooling

Coroutines are lightweight threads for asynchronous programming. They allow writing asynchronous code in a sequential manner. Key concepts: 1) suspend functions - can be paused and resumed, 2) CoroutineScope - defines lifecycle, 3) Dispatchers - control thread execution (Main, IO, Default), 4) launch{} - fire-and-forget, 5) async{} - returns result. Example: suspend fun fetchData() { delay(1000) }. Coroutines are more efficient than threads.