// Kotlin Basics Examples fun main() { // 1. Variables and Types val immutable = "Cannot be reassigned" // Read-only var mutable = "Can be changed" // Mutable mutable = "New value" // Type inference val inferredString = "Hello" // Compiler knows it's String val inferredInt = 42 // Compiler knows it's Int // Explicit types val explicitDouble: Double = 3.14 val explicitList: List = listOf("a", "b", "c") // 2. Basic Types val boolean: Boolean = true val char: Char = 'K' val byte: Byte = 127 val short: Short = 32767 val int: Int = 2147483647 val long: Long = 9223372036854775807L val float: Float = 3.14f val double: Double = 3.141592653589793 // 3. Strings and Templates val name = "Kotlin" val greeting = "Hello, $name!" // String interpolation val lengthMessage = "$name has ${name.length} characters" // Multi-line string val json = """ { "name": "$name", "version": "1.8", "features": ["null-safety", "coroutines", "dsl"] } """.trimIndent() // 4. Arrays val array = arrayOf(1, 2, 3, 4, 5) val typedArray = intArrayOf(1, 2, 3) // Primitive array val arrayWithNulls = arrayOfNulls(5) // 5. Type Checks and Casts val obj: Any = "I'm a string" // Smart cast after type check if (obj is String) { println(obj.uppercase()) // No explicit cast needed } // Safe cast returns null if not possible val number: Int? = obj as? Int println("Safe cast result: $number") // 6. Basic Operations val a = 10 val b = 3 println("a + b = ${a + b}") println("a - b = ${a - b}") println("a * b = ${a * b}") println("a / b = ${a / b}") // Integer division println("a % b = ${a % b}") // Range operator val range = 1..10 val exclusiveRange = 1 until 10 val descendingRange = 10 downTo 1 val stepRange = 1..10 step 2 // 7. Equality val str1 = "Hello" val str2 = String("Hello".toCharArray()) println("str1 == str2: ${str1 == str2}") // Structural equality println("str1 === str2: ${str1 === str2}") // Referential equality // 8. Basic Control Flow val score = 85 // If as expression val grade = if (score >= 90) { "A" } else if (score >= 80) { "B" } else if (score >= 70) { "C" } else { "F" } println("Score: $score, Grade: $grade") // When expression (powerful switch) val day = 3 val dayName = when (day) { 1 -> "Monday" 2 -> "Tuesday" 3 -> "Wednesday" 4 -> "Thursday" 5 -> "Friday" 6, 7 -> "Weekend" in 8..31 -> "Invalid day" else -> "Unknown" } println("Day $day is $dayName") // Loops for (i in 1..5) { print("$i ") } println() for (i in 1 until 5) { print("$i ") } println() for (i in 5 downTo 1) { print("$i ") } println() // Iterating with index val fruits = listOf("Apple", "Banana", "Cherry") for ((index, fruit) in fruits.withIndex()) { println("Fruit $index: $fruit") } // While loop var count = 5 while (count > 0) { print("$count ") count-- } println() // Do-while loop var input: String do { print("Enter 'quit' to exit: ") input = readLine() ?: "" } while (input != "quit") println("Basics complete!") }

// Variables and Types Examples fun main() { println("=== Variables and Types ===") // 1. val vs var val immutableVal = "I cannot be reassigned" // immutableVal = "New value" // Compilation error var mutableVar = "I can be changed" mutableVar = "New value allowed" // 2. Type inference examples val inferredInt = 42 // Int val inferredDouble = 3.14 // Double val inferredString = "Hello" // String val inferredBoolean = true // Boolean val inferredList = listOf(1, 2, 3) // List // 3. Explicit type declarations val explicitLong: Long = 10000000000L val explicitFloat: Float = 3.14f val explicitArray: Array = arrayOf(1, 2, 3) // 4. Nullable types var nullableString: String? = null // Can be null var nonNullableString: String = "Hello" // Cannot be null // nonNullableString = null // Compilation error // Safe calls val length = nullableString?.length // Returns null if nullableString is null println("Length of nullable string: $length") // Elvis operator (default value) val safeLength = nullableString?.length ?: 0 println("Safe length: $safeLength") // Non-null assertion (use with caution!) nullableString = "Now I have a value" val assertedLength = nullableString!!.length println("Asserted length: $assertedLength") // 5. Type checks and smart casts fun processValue(value: Any) { when (value) { is String -> { // Smart cast to String println("String length: ${value.length}") } is Int -> { // Smart cast to Int println("Int value doubled: ${value * 2}") } is List<*> -> { // Smart cast to List println("List size: ${value.size}") } else -> { println("Unknown type") } } } processValue("Kotlin") processValue(42) processValue(listOf(1, 2, 3)) // 6. Type aliases typealias UserId = String typealias UserMap = Map val userId: UserId = "user123" val users: UserMap = mapOf("user123" to "Alice", "user456" to "Bob") // 7. Arrays val intArray = intArrayOf(1, 2, 3, 4, 5) val stringArray = arrayOf("Apple", "Banana", "Cherry") val mixedArray = arrayOf(1, "Two", 3.0, true) // Array operations println("Int array size: ${intArray.size}") println("First element: ${stringArray[0]}") println("Last element: ${stringArray[stringArray.lastIndex]}") // 8. Type conversions val intValue: Int = 42 val longValue: Long = intValue.toLong() // Explicit conversion needed val doubleValue: Double = intValue.toDouble() val stringValue: String = intValue.toString() // 9. Properties with custom accessors class Rectangle(val width: Int, val height: Int) { // Computed property val area: Int get() = width * height // Property with backing field var scale: Double = 1.0 set(value) { if (value > 0) { field = value } else { println("Scale must be positive") } } // Lazy property val diagonal: Double by lazy { Math.sqrt((width * width + height * height).toDouble()) } } val rect = Rectangle(10, 20) println("Rectangle area: ${rect.area}") println("Rectangle diagonal: ${rect.diagonal}") rect.scale = 2.0 println("Scale set to: ${rect.scale}") // 10. Late initialization class Service { lateinit var data: String fun initialize() { data = "Initialized data" } fun process() { // Check if initialized if (::data.isInitialized) { println("Processing: $data") } else { println("Data not initialized") } } } val service = Service() service.process() service.initialize() service.process() // 11. Delegated properties class User { var name: String by Delegates.observable("") { prop, old, new -> println("$old -> $new") } var age: Int by Delegates.vetoable(0) { prop, old, new -> new >= 0 // Only allow positive ages } } val user = User() user.name = "Alice" user.name = "Bob" user.age = 25 user.age = -5 // Won't change (vetoed) println("User age: ${user.age}") // 12. Any, Unit, Nothing val anyValue: Any = "Can be anything" val unitValue: Unit = println("Returns Unit") // Similar to void fun neverReturns(): Nothing { throw RuntimeException("This function never returns normally") } // 13. Type parameters and generics class Box(val value: T) { fun getValue(): T = value } val intBox = Box(42) val stringBox = Box("Hello") println("Box values: ${intBox.getValue()}, ${stringBox.getValue()}") println("\nVariables and Types demonstration complete!") }

// Functions in Kotlin Examples fun main() { println("=== Functions in Kotlin ===") // 1. Basic function fun greet(name: String): String { return "Hello, $name!" } println(greet("Kotlin Developer")) // 2. Single-expression function fun square(x: Int) = x * x fun isEven(n: Int) = n % 2 == 0 println("Square of 5: ${square(5)}") println("Is 6 even? ${isEven(6)}") // 3. Default arguments fun createMessage( text: String, prefix: String = "Info", suffix: String = "End of message", times: Int = 1 ): String { return "$prefix: ${text.repeat(times)} ($suffix)" } println(createMessage("Hello")) // Uses all defaults println(createMessage("Hello", "Warning")) // Custom prefix println(createMessage("Hello", times = 3)) // Named argument // 4. Named arguments fun formatUser( firstName: String, lastName: String, age: Int, email: String = "", phone: String = "" ) { println("User: $firstName $lastName, Age: $age") if (email.isNotEmpty()) println("Email: $email") if (phone.isNotEmpty()) println("Phone: $phone") } formatUser("John", "Doe", 30) formatUser( firstName = "Jane", lastName = "Smith", age = 25, email = "jane@example.com" ) // Can change order with named arguments formatUser( age = 35, lastName = "Brown", firstName = "Bob", phone = "555-1234" ) // 5. Extension functions fun String.addExclamation() = "$this!" fun Int.isPositive() = this > 0 fun List.product(): Int = this.fold(1) { acc, i -> acc * i } println("Hello".addExclamation()) println("Is 5 positive? ${5.isPositive()}") println("Product of [1, 2, 3, 4]: ${listOf(1, 2, 3, 4).product()}") // 6. Infix functions infix fun Int.times(str: String) = str.repeat(this) infix fun String.onto(other: String) = Pair(this, other) println(3 times "Hi ") // Using infix notation println("Kotlin" onto "Java") class Person(val name: String) { infix fun likes(thing: String) = "$name likes $thing" } val alice = Person("Alice") println(alice likes "programming") // 7. Operator overloading data class Point(val x: Int, val y: Int) { operator fun plus(other: Point) = Point(x + other.x, y + other.y) operator fun minus(other: Point) = Point(x - other.x, y - other.y) operator fun times(factor: Int) = Point(x * factor, y * factor) operator fun component1() = x // For destructuring operator fun component2() = y } val p1 = Point(10, 20) val p2 = Point(5, 5) println("p1 + p2 = ${p1 + p2}") println("p1 * 3 = ${p1 * 3}") // Destructuring using component operators val (x, y) = p1 println("Destructured: x=$x, y=$y") // 8. Local functions fun processNumbers(vararg numbers: Int) { // Local function fun validate(n: Int): Boolean { return n in 1..100 } val validNumbers = numbers.filter { validate(it) } println("Valid numbers: $validNumbers") } processNumbers(10, 150, 30, -5, 75) // 9. Tail recursive functions tailrec fun factorial(n: Int, accumulator: Int = 1): Int { return if (n <= 1) accumulator else factorial(n - 1, n * accumulator) } println("Factorial of 5: ${factorial(5)}") // 10. Higher-order functions fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int { return operation(x, y) } val sum = calculate(10, 5) { a, b -> a + b } val product = calculate(10, 5) { a, b -> a * b } println("Sum: $sum, Product: $product") // Function returning function fun multiplier(factor: Int): (Int) -> Int { return { number -> number * factor } } val double = multiplier(2) val triple = multiplier(3) println("Double 5: ${double(5)}") println("Triple 5: ${triple(5)}") // 11. Lambda expressions val numbers = listOf(1, 2, 3, 4, 5) // Traditional lambda val squares = numbers.map { n -> n * n } // Using it for single parameter val evens = numbers.filter { it % 2 == 0 } // Multi-line lambda val processed = numbers.map { println("Processing $it") it * 2 + 1 } println("Squares: $squares") println("Evens: $evens") println("Processed: $processed") // 12. Function references fun isPrime(n: Int): Boolean { if (n <= 1) return false for (i in 2..n/2) { if (n % i == 0) return false } return true } val primes = (1..20).filter(::isPrime) println("Primes 1-20: $primes") // 13. Inline functions inline fun measureTime(block: () -> Unit): Long { val start = System.currentTimeMillis() block() return System.currentTimeMillis() - start } val time = measureTime { // This code block is inlined at compile time var sum = 0 for (i in 1..1000000) { sum += i } } println("Computation took ${time}ms") // 14. Varargs fun sumAll(vararg numbers: Int): Int { return numbers.sum() } println("Sum: ${sumAll(1, 2, 3, 4, 5)}") // Spread operator val arr = intArrayOf(10, 20, 30) println("Sum from array: ${sumAll(*arr)}") // 15. Generic functions fun printList(list: List) { list.forEach { println(it) } } fun > maxOf(a: T, b: T): T { return if (a > b) a else b } println("Max of 10 and 20: ${maxOf(10, 20)}") println("Max of 'a' and 'b': ${maxOf("a", "b")}") println("\nFunctions demonstration complete!") }

// Control Flow Examples fun main() { println("=== Control Flow in Kotlin ===") // 1. If expression (not statement) val a = 10 val b = 20 // Traditional if-else val max1 = if (a > b) a else b println("Max of $a and $b is $max1") // Multi-line if expression (last expression is returned) val description = if (a > b) { println("a is greater") "a is greater" } else if (a < b) { println("b is greater") "b is greater" } else { println("a and b are equal") "a and b are equal" } println("Description: $description") // 2. When expression (replaces switch) val day = 3 // Basic when val dayName = when (day) { 1 -> "Monday" 2 -> "Tuesday" 3 -> "Wednesday" 4 -> "Thursday" 5 -> "Friday" 6, 7 -> "Weekend" else -> "Invalid day" } println("Day $day is $dayName") // When with ranges val score = 85 val grade = when (score) { in 90..100 -> "A" in 80..89 -> "B" in 70..79 -> "C" in 60..69 -> "D" else -> "F" } println("Score $score gets grade $grade") // When with type checks and smart casts fun describe(obj: Any): String = when (obj) { is String -> "String with length ${obj.length}" is Int -> "Integer: $obj" is List<*> -> "List with ${obj.size} elements" else -> "Unknown type" } println(describe("Hello")) println(describe(42)) println(describe(listOf(1, 2, 3))) // When without argument (replaces if-else chains) val hour = 14 val timeOfDay = when { hour < 12 -> "Morning" hour < 17 -> "Afternoon" hour < 21 -> "Evening" else -> "Night" } println("At $hour:00 it's $timeOfDay") // 3. For loops // Range iteration println("Counting up:") for (i in 1..5) { print("$i ") } println() println("Counting down:") for (i in 5 downTo 1) { print("$i ") } println() println("With step:") for (i in 1..10 step 2) { print("$i ") } println() println("Exclusive range:") for (i in 1 until 5) { print("$i ") } println() // Collection iteration val fruits = listOf("Apple", "Banana", "Cherry", "Date") println("Fruits:") for (fruit in fruits) { print("$fruit ") } println() // Iteration with index println("Fruits with index:") for ((index, fruit) in fruits.withIndex()) { println(" $index: $fruit") } // Iteration with indices property println("Using indices:") for (i in fruits.indices) { println(" $i: ${fruits[i]}") } // Map iteration val map = mapOf("A" to 1, "B" to 2, "C" to 3) println("Map entries:") for ((key, value) in map) { println(" $key -> $value") } // String iteration val text = "Kotlin" println("Characters in '$text':") for (ch in text) { print("$ch ") } println() // 4. While and do-while loops println("While loop:") var count = 5 while (count > 0) { print("$count ") count-- } println() println("Do-while loop (always executes at least once):") var input: String do { print("Enter 'exit' to quit: ") input = readLine() ?: "" println("You entered: $input") } while (input != "exit") // 5. Break and continue println("Break example:") for (i in 1..10) { if (i == 5) { println("Breaking at 5") break } print("$i ") } println() println("Continue example:") for (i in 1..10) { if (i % 2 == 0) { continue // Skip even numbers } print("$i ") } println() // 6. Labeled breaks and continues println("Labeled break (outer loop):") outer@ for (i in 1..3) { inner@ for (j in 1..3) { if (i == 2 && j == 2) { break@outer // Break outer loop } println("i=$i, j=$j") } } println("Labeled continue:") outer@ for (i in 1..3) { for (j in 1..3) { if (j == 2) { continue@outer // Continue outer loop } println("i=$i, j=$j") } } // 7. Exception handling println("\nException handling:") // Try as expression val numberStr = "123" val parsedNumber = try { numberStr.toInt() } catch (e: NumberFormatException) { println("Could not parse '$numberStr' as number") null } println("Parsed number: $parsedNumber") // Multiple catch blocks fun riskyOperation(value: String): Int { return try { val num = value.toInt() if (num < 0) throw IllegalArgumentException("Negative number") 100 / num // Could throw ArithmeticException } catch (e: NumberFormatException) { println("Invalid number format: ${e.message}") 0 } catch (e: ArithmeticException) { println("Arithmetic error: ${e.message}") -1 } catch (e: IllegalArgumentException) { println("Illegal argument: ${e.message}") -2 } finally { println("Finally block always executes") } } println("Result 1: ${riskyOperation("10")}") println("Result 2: ${riskyOperation("0")}") println("Result 3: ${riskyOperation("abc")}") println("Result 4: ${riskyOperation("-5")}") // Throw expression fun requirePositive(value: Int): Int { return if (value > 0) { value } else { throw IllegalArgumentException("Value must be positive: $value") } } try { println("Positive check 1: ${requirePositive(10)}") println("Positive check 2: ${requirePositive(-5)}") // Will throw } catch (e: IllegalArgumentException) { println("Caught: ${e.message}") } // 8. Scope functions for control flow println("\nScope functions for control flow:") val nullableString: String? = "Hello" // let for null checks and transformations nullableString?.let { println("String is not null: $it") println("Length: ${it.length}") } // run for object configuration and computing result val result = "Hello".run { println("Processing: $this") length * 2 } println("Run result: $result") // with for calling multiple methods on same object val list = mutableListOf() with(list) { add("First") add("Second") add("Third") println("List has ${size} items: $this") } // apply for object initialization val person = Person("").apply { name = "Alice" age = 30 println("Initialized: $name, $age") } // also for side effects val numbersList = mutableListOf(1, 2, 3) numbersList.also { println("Before adding: $it") it.add(4) println("After adding: $it") } // 9. TakeIf and takeUnless val inputValue = "42" val parsed = inputValue.takeIf { it.all { char -> char.isDigit() } }?.toInt() println("Parsed if all digits: $parsed") val filtered = inputValue.takeUnless { it.isEmpty() } println("Take unless empty: $filtered") println("\nControl flow demonstration complete!") } // Helper class class Person(var name: String) { var age: Int = 0 }

// Null Safety Examples fun main() { println("=== Null Safety in Kotlin ===") // 1. Nullable vs non-nullable types var nonNullable: String = "Hello" // Cannot be null // nonNullable = null // Compilation error var nullable: String? = "Hello" // Can be null nullable = null // This is allowed // 2. Safe call operator (?.) val length1 = nullable?.length // Returns null if nullable is null println("Length with safe call: $length1") // Chain safe calls class Address(val city: String?) class User(val name: String, val address: Address?) val user1: User? = User("Alice", Address("New York")) val user2: User? = User("Bob", null) val user3: User? = null val city1 = user1?.address?.city // "New York" val city2 = user2?.address?.city // null val city3 = user3?.address?.city // null println("Cities: $city1, $city2, $city3") // Safe call with method calls val uppercaseCity = user1?.address?.city?.uppercase() println("Uppercase city: $uppercaseCity") // 3. Elvis operator (?:) val name1: String? = "Alice" val name2: String? = null val displayName1 = name1 ?: "Anonymous" val displayName2 = name2 ?: "Anonymous" println("Display names: $displayName1, $displayName2") // Elvis with throw fun requireNotNull(value: String?): String { return value ?: throw IllegalArgumentException("Value cannot be null") } try { println("Required: ${requireNotNull("Valid")}") println("Required: ${requireNotNull(null)}") // Throws } catch (e: IllegalArgumentException) { println("Caught: ${e.message}") } // Elvis with return fun processUser(user: User?) { val userName = user?.name ?: return // Return early if null println("Processing user: $userName") } processUser(User("Charlie", null)) processUser(null) // 4. Non-null assertion (!!) - Use with caution! val definitelyNotNull: String? = "I'm definitely not null" val forcedLength = definitelyNotNull!!.length // We're sure it's not null println("Forced length: $forcedLength") // Dangerous example (will crash at runtime) val risky: String? = null // val crash = risky!!.length // Throws NullPointerException // 5. Safe casts (as?) val obj: Any = "I'm a string" val asString: String? = obj as? String // Safe cast, returns String val asInt: Int? = obj as? Int // Safe cast, returns null println("Safe cast to String: $asString") println("Safe cast to Int: $asInt") // 6. let, also, run, with, apply with null safety val nullableValue: String? = "Hello" // let executes block only if not null nullableValue?.let { println("Value is not null: $it") println("Length: ${it.length}") } // also for side effects nullableValue?.also { println("Also: $it") } // 7. Collections with nulls val listWithNulls: List = listOf(1, 2, null, 4, null, 6) println("List with nulls: $listWithNulls") // Filter out nulls val withoutNulls: List = listWithNulls.filterNotNull() println("Without nulls: $withoutNulls") // Map with null handling val mapped = listWithNulls.map { it?.times(2) } println("Mapped (keeping nulls): $mapped") val mappedNotNull = listWithNulls.mapNotNull { it?.times(2) } println("Mapped (filtering nulls): $mappedNotNull") // 8. Platform types from Java // When calling Java code, Kotlin doesn't know nullability // Java: public String getUserName() { ... } // Kotlin sees this as: fun getUserName(): String! // You can assign to nullable or non-nullable val fromJava1: String = JavaInterop.getUserName() // Assume not null val fromJava2: String? = JavaInterop.getUserName() // Handle possible null println("From Java (non-null): $fromJava1") println("From Java (nullable): $fromJava2") // 9. Late initialization (lateinit) class Service { lateinit var data: String // Will be initialized later fun initialize() { data = "Initialized" } fun process() { // Check if initialized if (::data.isInitialized) { println("Processing: $data") } else { println("Data not initialized yet") } } } val service = Service() service.process() service.initialize() service.process() // 10. Delegates for null safety import kotlin.properties.Delegates class UserProfile { // Not null, must be initialized in constructor or init block var username: String by Delegates.notNull() // Observable property var email: String by Delegates.observable("") { prop, old, new -> println("Email changed: $old -> $new") } // Vetoable - can reject changes var age: Int by Delegates.vetoable(0) { _, old, new -> if (new >= 0) { true // Accept change } else { println("Age cannot be negative: $new") false // Reject change } } } val profile = UserProfile() profile.username = "alice123" // Must be set before use profile.email = "alice@example.com" profile.email = "alice.new@example.com" profile.age = 25 profile.age = -5 // Will be rejected println("Profile age: ${profile.age}") // 11. Type parameter nullability fun printHashCode(t: T) { // T is non-nullable println("Hash code: ${t.hashCode()}") } // printHashCode(null) // Compilation error printHashCode("Hello") fun printHashCodeNullable(t: T) { // T can be nullable println("Hash code nullable: ${t?.hashCode()}") } printHashCodeNullable("Hello") printHashCodeNullable(null) // 12. Null safety in when expressions fun describeValue(value: Any?): String { return when (value) { null -> "It's null" is String -> "String of length ${value.length}" is Int -> "Integer: $value" else -> "Unknown type" } } println(describeValue(null)) println(describeValue("Kotlin")) println(describeValue(42)) // 13. TakeIf and takeUnless val input = "123" val number = input.takeIf { it.all { char -> char.isDigit() } }?.toInt() println("Number if all digits: $number") val notEmpty = input.takeUnless { it.isEmpty() } println("Take unless empty: $notEmpty") // 14. Custom null safety extensions fun String?.orEmpty(): String = this ?: "" fun String?.toIntOrZero(): Int = this?.toIntOrNull() ?: 0 val maybeString: String? = null println("Or empty: '${maybeString.orEmpty()}'") println("To int or zero: ${maybeString.toIntOrZero()}") val maybeNumber: String? = "42" println("To int or zero (valid): ${maybeNumber.toIntOrZero()}") println("\nNull safety demonstration complete!") } // Simulated Java interop object JavaInterop { fun getUserName(): String { return "JavaUser" } }

// OOP in Kotlin Examples fun main() { println("=== Object-Oriented Programming in Kotlin ===") // 1. Basic class with primary constructor class Person(val name: String, var age: Int) { // Property with custom getter val isAdult: Boolean get() = age >= 18 // Method fun greet() { println("Hello, I'm $name and I'm $age years old") } } val alice = Person("Alice", 25) alice.greet() println("Is Alice adult? ${alice.isAdult}") // 2. Properties with backing fields class Rectangle(width: Int, height: Int) { var width = width set(value) { if (value > 0) { field = value } else { println("Width must be positive") } } var height = height set(value) { if (value > 0) { field = value } } // Computed property (no backing field) val area: Int get() = width * height } val rect = Rectangle(10, 20) println("Rectangle area: ${rect.area}") rect.width = -5 // Will print warning println("Width after invalid set: ${rect.width}") // 3. Inheritance open class Animal(val name: String) { // open allows inheritance open fun makeSound() { // open allows overriding println("$name makes a sound") } fun eat() { println("$name is eating") } } class Dog(name: String, val breed: String) : Animal(name) { override fun makeSound() { println("$name (a $breed) barks!") } fun fetch() { println("$name is fetching") } } val dog = Dog("Rex", "Golden Retriever") dog.makeSound() dog.eat() dog.fetch() // 4. Abstract classes abstract class Shape { abstract fun area(): Double abstract fun perimeter(): Double fun description() { println("Area: ${area()}, Perimeter: ${perimeter()}") } } class Circle(val radius: Double) : Shape() { override fun area() = Math.PI * radius * radius override fun perimeter() = 2 * Math.PI * radius } val circle = Circle(5.0) circle.description() // 5. Interfaces interface Drawable { fun draw() val color: String // Abstract property fun description() { // Default implementation println("Drawable with color $color") } } interface Clickable { fun click() fun show() = println("Showing clickable element") // Default implementation } class Button(override val color: String) : Drawable, Clickable { override fun draw() { println("Drawing button with color $color") } override fun click() { println("Button clicked!") } // Can override default implementation override fun show() { super.show() // Call super from specific interface println("Button specific show") } } val button = Button("Blue") button.draw() button.click() button.description() button.show() // 6. Data classes data class User(val id: Int, val username: String, val email: String) val user1 = User(1, "alice", "alice@example.com") val user2 = User(1, "alice", "alice@example.com") val user3 = User(2, "bob", "bob@example.com") println("user1: $user1") println("user1 == user2: ${user1 == user2}") // true - structural equality println("user1 === user2: ${user1 === user2}") // false - different references // Copy with modification val user1Updated = user1.copy(email = "alice.new@example.com") println("Updated user: $user1Updated") // Destructuring val (id, username, email) = user1 println("Destructured: id=$id, username=$username, email=$email") // Component functions (auto-generated) println("Components: ${user1.component1()}, ${user1.component2()}, ${user1.component3()}") // 7. Sealed classes (restricted hierarchies) sealed class Result { data class Success(val data: String) : Result() data class Error(val message: String, val code: Int) : Result() object Loading : Result() } fun handleResult(result: Result) { // Exhaustive when (no else needed - compiler knows all cases) when (result) { is Result.Success -> println("Success: ${result.data}") is Result.Error -> println("Error ${result.code}: ${result.message}") Result.Loading -> println("Loading...") } } handleResult(Result.Success("Data loaded")) handleResult(Result.Error("Not found", 404)) handleResult(Result.Loading) // 8. Objects (singletons) object Logger { private var level = "INFO" fun log(message: String) { println("[$level] $message") } fun setLevel(newLevel: String) { level = newLevel } } Logger.log("Application started") Logger.setLevel("DEBUG") Logger.log("Debug message") // 9. Companion objects (static members) class DatabaseClient private constructor(val url: String) { companion object Factory { private val instances = mutableMapOf() fun getInstance(url: String): DatabaseClient { return instances.getOrPut(url) { DatabaseClient(url) } } const val DEFAULT_URL = "localhost:5432" } fun connect() { println("Connected to $url") } } val db1 = DatabaseClient.getInstance("localhost:5432") val db2 = DatabaseClient.getInstance("localhost:5432") // Same instance val db3 = DatabaseClient.getInstance("remote:5432") // Different instance println("db1 === db2: ${db1 === db2}") // true println("db1 === db3: ${db1 === db3}") // false db1.connect() println("Default URL: ${DatabaseClient.DEFAULT_URL}") // 10. Nested and inner classes class Outer { private val outerValue = "Outer" // Nested class (no access to outer instance) class Nested { fun getValue() = "From nested" } // Inner class (has access to outer instance) inner class Inner { fun getValue() = "From inner accessing $outerValue" } } val nested = Outer.Nested() println("Nested: ${nested.getValue()}") val outer = Outer() val inner = outer.Inner() println("Inner: ${inner.getValue()}") // 11. Object expressions (anonymous objects) interface EventListener { fun onEvent(event: String) } val listener = object : EventListener { override fun onEvent(event: String) { println("Event received: $event") } // Can have additional members val creationTime = System.currentTimeMillis() } listener.onEvent("click") println("Listener created at: ${listener.creationTime}") // 12. Visibility modifiers class VisibilityExample { public val publicProperty = "Everyone can see me" internal val internalProperty = "Same module only" protected val protectedProperty = "Subclasses can see me" private val privateProperty = "Only this class can see me" fun test() { println(publicProperty) println(internalProperty) println(protectedProperty) println(privateProperty) } } class Subclass : VisibilityExample() { fun testSubclass() { println(publicProperty) println(internalProperty) println(protectedProperty) // OK - protected is visible // println(privateProperty) // Error - private not visible } } // 13. Delegation interface Base { fun print() } class BaseImpl(val x: Int) : Base { override fun print() { println("BaseImpl: $x") } } // Delegation using "by" keyword class Derived(b: Base) : Base by b { // Can override if needed override fun print() { println("Derived before") // b.print() // Called automatically by delegation println("Derived after") } } val base = BaseImpl(10) Derived(base).print() // 14. Property delegation class DelegateExample { var delegatedProperty: String by Delegate() } class Delegate { private var backingField = "Default" operator fun getValue(thisRef: Any?, property: kotlin.reflect.KProperty<*>): String { println("Getting ${property.name}") return backingField } operator fun setValue(thisRef: Any?, property: kotlin.reflect.KProperty<*>, value: String) { println("Setting ${property.name} to $value") backingField = value } } val example = DelegateExample() println("Initial value: ${example.delegatedProperty}") example.delegatedProperty = "New Value" println("Updated value: ${example.delegatedProperty}") // 15. Enum classes enum class Color(val rgb: Int) { RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF), YELLOW(0xFFFF00); fun containsRed() = (rgb and 0xFF0000) != 0 } println("Colors:") for (color in Color.values()) { println(" $color (${color.rgb.toString(16)}) contains red? ${color.containsRed()}") } val selected = Color.valueOf("RED") println("Selected color: $selected, ordinal: ${selected.ordinal}") println("\nOOP demonstration complete!") }

// Classes and Objects Examples fun main() { println("=== Classes and Objects in Kotlin ===") // 1. Basic class with primary constructor class Person constructor(firstName: String) { // constructor keyword optional val name: String init { // Initializer block name = firstName.capitalize() println("Person initialized with name: $name") } } val person1 = Person("alice") println("Person name: ${person1.name}") // 2. Concise primary constructor with properties class User(val username: String, var age: Int) { // Properties automatically created from constructor parameters fun describe() { println("User: $username, Age: $age") } } val user = User("john_doe", 30) user.describe() user.age = 31 // Setter available because age is var user.describe() // 3. Secondary constructors class Car(val make: String, val model: String) { var year: Int = 2023 // Secondary constructor must delegate to primary constructor(make: String, model: String, year: Int) : this(make, model) { this.year = year println("Car created with year: $year") } // Another secondary constructor constructor(make: String) : this(make, "Unknown") { println("Car created with unknown model") } fun info() { println("$year $make $model") } } val car1 = Car("Toyota", "Camry") val car2 = Car("Honda", "Accord", 2020) val car3 = Car("Ford") car1.info() car2.info() car3.info() // 4. Properties with custom accessors class Rectangle(width: Int, height: Int) { var width = width set(value) { if (value > 0) { field = value // field refers to backing field } else { println("Width must be positive") } } var height = height get() { println("Getting height: $field") return field } set(value) { println("Setting height from $field to $value") field = value } // Computed property (no backing field) val area: Int get() = width * height // Property with private setter var scale: Double = 1.0 private set fun doubleScale() { scale *= 2 } } val rect = Rectangle(10, 20) println("Rectangle area: ${rect.area}") rect.width = 15 rect.height = 25 println("New area: ${rect.area}") rect.doubleScale() println("Scale: ${rect.scale}") // rect.scale = 3.0 // Error - setter is private // 5. Lazy properties class HeavyComputation { val expensiveResult: String by lazy { println("Computing expensive result...") // Simulate expensive computation Thread.sleep(1000) "Computed Result" } } val computation = HeavyComputation() println("Before accessing lazy property") println("Lazy property: ${computation.expensiveResult}") println("Lazy property (cached): ${computation.expensiveResult}") // 6. Late initialization class DatabaseService { lateinit var connection: String fun connect() { connection = "Connected to database" } fun query() { if (::connection.isInitialized) { println("Querying using: $connection") } else { println("Not connected yet") } } } val service = DatabaseService() service.query() service.connect() service.query() // 7. Companion objects (static members) class MathUtils { companion object { const val PI = 3.14159 fun circleArea(radius: Double): Double { return PI * radius * radius } // Factory method fun create(): MathUtils = MathUtils() } fun instanceMethod() { println("I'm an instance method") } } // Access companion members using class name println("PI: ${MathUtils.PI}") println("Circle area: ${MathUtils.circleArea(5.0)}") val utils = MathUtils.create() utils.instanceMethod() // Named companion object class Logger { companion object Factory { fun createLogger(): Logger = Logger() } } val logger = Logger.Factory.createLogger() // 8. Object declarations (singletons) object ApplicationConfig { private const val VERSION = "1.0.0" var debugMode = false fun printConfig() { println("Version: $VERSION, Debug: $debugMode") } } ApplicationConfig.debugMode = true ApplicationConfig.printConfig() // 9. Object expressions (anonymous objects) interface ClickListener { fun onClick() } val buttonListener = object : ClickListener { override fun onClick() { println("Button clicked!") } // Can have additional properties/methods val clickCount = 0 } buttonListener.onClick() println("Click count: ${buttonListener.clickCount}") // Object expression without supertype val adHoc = object { val x = 10 val y = 20 fun sum() = x + y } println("Ad hoc object sum: ${adHoc.sum()}") // 10. Nested and inner classes class OuterClass(val outerValue: String) { // Nested class (no access to outer instance) class NestedClass { fun nestedMethod() = "From nested class" } // Inner class (has access to outer instance) inner class InnerClass { fun innerMethod() = "From inner class accessing $outerValue" fun getOuterReference(): OuterClass = this@OuterClass } } val outer = OuterClass("Outer Value") val nested = OuterClass.NestedClass() val inner = outer.InnerClass() println("Nested: ${nested.nestedMethod()}") println("Inner: ${inner.innerMethod()}") println("Inner gets outer: ${inner.getOuterReference().outerValue}") // 11. Data classes data class Product(val id: Int, val name: String, val price: Double) { // Can have additional members fun formattedPrice() = "$${"%.2f".format(price)}" } val product1 = Product(1, "Laptop", 999.99) val product2 = Product(1, "Laptop", 999.99) val product3 = product1.copy(id = 2, price = 1099.99) println("Product1: $product1") println("Product1 formatted: ${product1.formattedPrice()}") println("product1 == product2: ${product1 == product2}") println("product1 === product2: ${product1 === product2}") println("Product3 (copy modified): $product3") // Destructuring val (id, name, price) = product1 println("Destructured: id=$id, name=$name, price=$price") // 12. Enum classes enum class Direction(val degrees: Int) { NORTH(0), EAST(90), SOUTH(180), WEST(270); fun opposite(): Direction { return when (this) { NORTH -> SOUTH EAST -> WEST SOUTH -> NORTH WEST -> EAST } } } val current = Direction.EAST println("Current direction: $current (${current.degrees}°)") println("Opposite direction: ${current.opposite()}") // Iterating enum values println("All directions:") for (direction in Direction.values()) { println(" $direction - ${direction.degrees}°") } // 13. Sealed classes sealed class NetworkResponse { data class Success(val data: String, val code: Int) : NetworkResponse() data class Error(val message: String, val code: Int) : NetworkResponse() object Loading : NetworkResponse() fun isSuccess(): Boolean = this is Success } fun handleResponse(response: NetworkResponse) { when (response) { is NetworkResponse.Success -> { println("Success: ${response.code} - ${response.data}") } is NetworkResponse.Error -> { println("Error: ${response.code} - ${response.message}") } NetworkResponse.Loading -> { println("Loading...") } // No else needed - compiler knows all cases are covered } } handleResponse(NetworkResponse.Success("Data", 200)) handleResponse(NetworkResponse.Error("Not Found", 404)) handleResponse(NetworkResponse.Loading) // 14. Value classes (inline classes) - Kotlin 1.5+ @JvmInline value class Password(val value: String) { init { require(value.length >= 8) { "Password must be at least 8 characters" } } fun strength(): String { return when (value.length) { in 8..11 -> "Weak" in 12..15 -> "Medium" else -> "Strong" } } } @JvmInline value class Email(val value: String) { init { require(value.contains("@")) { "Invalid email format" } } } fun authenticate(email: Email, password: Password) { println("Authenticating ${email.value} with password strength: ${password.strength()}") } val email = Email("user@example.com") val password = Password("securePass123") authenticate(email, password) // 15. Abstract classes abstract class Shape { abstract fun area(): Double abstract fun perimeter(): Double fun description() { println("Shape: area=${area()}, perimeter=${perimeter()}") } } class Square(val side: Double) : Shape() { override fun area() = side * side override fun perimeter() = 4 * side } val square = Square(5.0) square.description() println("\nClasses and Objects demonstration complete!") }

// Inheritance Examples fun main() { println("=== Inheritance in Kotlin ===") // 1. Open classes and methods open class Animal(val name: String) { // Class must be open to inherit open fun makeSound() { // Method must be open to override println("$name makes a sound") } // Not open - cannot be overridden fun eat() { println("$name is eating") } open val sound: String = "Generic animal sound" } class Dog(name: String, val breed: String) : Animal(name) { // Must use override keyword override fun makeSound() { println("$name the $breed barks!") } // Can call superclass implementation fun makeGenericSound() { super.makeSound() } // Overriding property override val sound: String = "Woof!" } val dog = Dog("Rex", "Golden Retriever") dog.makeSound() // "Rex the Golden Retriever barks!" dog.makeGenericSound() // "Rex makes a sound" dog.eat() // "Rex is eating" (inherited, not overridden) println("Dog sound: ${dog.sound}") // 2. Primary constructor inheritance open class Vehicle(val wheels: Int, val color: String) { init { println("Vehicle with $wheels wheels created") } open fun drive() { println("Driving $color vehicle with $wheels wheels") } } class Car(color: String) : Vehicle(4, color) { // Car constructor passes arguments to Vehicle constructor init { println("Car created") } override fun drive() { println("Driving $color car") super.drive() // Call parent implementation } } val car = Car("Red") car.drive() // 3. Secondary constructors with inheritance open class Person(val name: String) { var age: Int = 0 constructor(name: String, age: Int) : this(name) { this.age = age println("Person $name created with age $age") } open fun introduce() { println("Hi, I'm $name") } } class Employee : Person { var salary: Double = 0.0 // Secondary constructor calling superclass secondary constructor constructor(name: String, age: Int, salary: Double) : super(name, age) { this.salary = salary println("Employee $name with salary $$salary created") } override fun introduce() { super.introduce() println("I earn $$salary per year") } } val employee = Employee("Alice", 30, 75000.0) employee.introduce() // 4. Property overriding open class Shape { open val vertexCount: Int = 0 open val name: String = "Shape" open fun description() { println("This is a $name with $vertexCount vertices") } } class Rectangle : Shape() { // Override val with val override val vertexCount: Int = 4 // Override val with var (allowed) override var name: String = "Rectangle" set(value) { field = value.capitalize() } // Custom property not in parent val area: Double = 0.0 // Would be calculated in real implementation } val rect = Rectangle() rect.name = "square" // Uses custom setter rect.description() // 5. Abstract classes abstract class Graphic { abstract val x: Int abstract val y: Int abstract fun draw() // Can have non-abstract members fun move(dx: Int, dy: Int) { println("Moving from ($x, $y) to (${x + dx}, ${y + dy})") } } class Circle(override val x: Int, override val y: Int, val radius: Int) : Graphic() { override fun draw() { println("Drawing circle at ($x, $y) with radius $radius") } } val circle = Circle(10, 20, 5) circle.draw() circle.move(5, -5) // 6. Multiple inheritance with interfaces interface Clickable { fun click() fun show() = println("Showing clickable") // Default implementation } interface Draggable { fun drag() fun show() = println("Showing draggable") // Default implementation with same name } class UIElement : Clickable, Draggable { override fun click() { println("UI element clicked") } override fun drag() { println("UI element dragged") } // Must override show() because both interfaces have default implementation override fun show() { super.show() // Call specific parent implementation super.show() println("UI element show") } } val element = UIElement() element.click() element.drag() element.show() // 7. Inheritance initialization order open class Base(val name: String) { init { println("Base init block: $name") } val baseProperty = "Base property".also { println("Base property initialized: $it") } } class Derived(name: String, val value: Int) : Base(name) { init { println("Derived init block: $name, value=$value") } val derivedProperty = "Derived property".also { println("Derived property initialized: $it") } } println("\nInitialization order demonstration:") val derived = Derived("Test", 42) /* Output order: Base init block: Test Base property initialized: Base property Derived init block: Test, value=42 Derived property initialized: Derived property */ // 8. Sealed class inheritance sealed class Expression { abstract fun evaluate(): Double } class Number(val value: Double) : Expression() { override fun evaluate() = value } class Sum(val left: Expression, val right: Expression) : Expression() { override fun evaluate() = left.evaluate() + right.evaluate() } class Product(val left: Expression, val right: Expression) : Expression() { override fun evaluate() = left.evaluate() * right.evaluate() } fun printExpression(expr: Expression) { when (expr) { is Number -> println("Number: ${expr.value}") is Sum -> println("Sum: ${expr.left.evaluate()} + ${expr.right.evaluate()}") is Product -> println("Product: ${expr.left.evaluate()} * ${expr.right.evaluate()}") // No else needed - compiler knows all subclasses } } val expression = Sum(Number(5.0), Product(Number(2.0), Number(3.0))) printExpression(expression) println("Result: ${expression.evaluate()}") // 9. Delegation instead of inheritance interface Printer { fun printDocument(document: String) } class LaserPrinter : Printer { override fun printDocument(document: String) { println("Laser printing: $document") } } // Using delegation instead of inheritance class OfficePrinter(private val printer: Printer) : Printer by printer { // Can add additional functionality fun printWithHeader(document: String) { println("=== Office Document ===") printDocument(document) println("=== End of Document ===") } // Can override delegated methods override fun printDocument(document: String) { println("Logging print job") printer.printDocument(document) println("Print job completed") } } val officePrinter = OfficePrinter(LaserPrinter()) officePrinter.printDocument("Report.pdf") officePrinter.printWithHeader("Memo.txt") // 10. Final modifier open class Parent { // This method is open but can be made final in subclass open fun canBeOverridden() { println("Parent implementation") } } class Child : Parent() { // Override but make it final so further subclasses can't override final override fun canBeOverridden() { println("Child implementation (final)") } } class GrandChild : Child() { // Can't override - method is final in Child // override fun canBeOverridden() { } // Error } // 11. Visibility in inheritance open class VisibilityBase { public val publicProp = "Public" protected val protectedProp = "Protected" internal val internalProp = "Internal" private val privateProp = "Private" protected open fun protectedMethod() { println("Base protected method") } } class VisibilityDerived : VisibilityBase() { // Can access protected members fun testAccess() { println(publicProp) println(protectedProp) // OK - protected is accessible in subclass println(internalProp) // println(privateProp) // Error - private not accessible protectedMethod() // OK } // Can override protected method override fun protectedMethod() { super.protectedMethod() println("Derived protected method") } } val derivedVis = VisibilityDerived() derivedVis.testAccess() // derivedVis.protectedProp // Error - protected not accessible outside println("\nInheritance demonstration complete!") }

// Interfaces Examples fun main() { println("=== Interfaces in Kotlin ===") // 1. Basic interface interface Drawable { fun draw() // Abstract method fun describe() { // Method with default implementation println("I'm drawable") } } class Circle : Drawable { override fun draw() { println("Drawing a circle") } } val circle = Circle() circle.draw() circle.describe() // Uses default implementation // 2. Interfaces with properties interface Shape { val vertexCount: Int // Abstract property val name: String // Property with getter implementation get() = "Shape" fun area(): Double // Abstract method fun perimeter(): Double { // Default implementation println("Default perimeter calculation for $name") return 0.0 } } class Triangle : Shape { override val vertexCount: Int = 3 override val name: String get() = "Triangle" val base: Double = 10.0 val height: Double = 5.0 override fun area(): Double { return 0.5 * base * height } // Can override default implementation override fun perimeter(): Double { println("Triangle perimeter calculation") return base * 3 // Simplified - equilateral triangle } } val triangle = Triangle() println("${triangle.name} has ${triangle.vertexCount} vertices") println("Area: ${triangle.area()}") println("Perimeter: ${triangle.perimeter()}") // 3. Multiple interface implementation interface Clickable { fun click() fun show() = println("Showing clickable") } interface Draggable { fun drag() fun show() = println("Showing draggable") // Same method name as Clickable } class Button : Clickable, Draggable { override fun click() { println("Button clicked") } override fun drag() { println("Button dragged") } // Must override show() because of conflict override fun show() { super.show() // Call Clickable's show super.show() // Call Draggable's show println("Button show") } } val button = Button() button.click() button.drag() button.show() // 4. Interface inheritance interface Animal { fun makeSound() } interface Pet : Animal { val name: String fun play() { println("$name is playing") } // Can override parent interface method with default override fun makeSound() { println("$name makes a pet sound") } } interface Mammal : Animal { fun feedYoung() } class Dog(override val name: String) : Pet, Mammal { // Implements makeSound() from Animal (through Pet) // Could override if needed override fun feedYoung() { println("$name is feeding puppies") } // Can add additional methods fun bark() { println("$name barks!") } } val dog = Dog("Buddy") dog.makeSound() // From Pet's default implementation dog.play() dog.feedYoung() dog.bark() // 5. Functional interfaces (SAM - Single Abstract Method) fun interface StringProcessor { fun process(input: String): String // Single abstract method } // Implementation using lambda val uppercaseProcessor = StringProcessor { it.uppercase() } val reverseProcessor = StringProcessor { it.reversed() } println("Uppercase: ${uppercaseProcessor.process("hello")}") println("Reversed: ${reverseProcessor.process("hello")}") // Traditional implementation class PrefixProcessor(val prefix: String) : StringProcessor { override fun process(input: String): String { return "$prefix$input" } } val prefixProcessor = PrefixProcessor(">>> ") println("Prefixed: ${prefixProcessor.process("hello")}") // 6. Using SAM interfaces as parameters fun processText(text: String, processor: StringProcessor): String { return processor.process(text) } val result1 = processText("kotlin", { it.capitalize() }) // Lambda as SAM val result2 = processText("kotlin") { it + " is awesome!" } // Trailing lambda println("Processed: $result1, $result2") // 7. Interface delegation interface Database { fun save(data: String) fun load(id: Int): String? } class RealDatabase : Database { private val storage = mutableMapOf() private var nextId = 1 override fun save(data: String) { storage[nextId++] = data println("Saved '$data' with id ${nextId - 1}") } override fun load(id: Int): String? { return storage[id].also { if (it != null) println("Loaded '$it' with id $id") else println("No data found for id $id") } } } // Decorator using delegation class LoggingDatabase(private val database: Database) : Database by database { override fun save(data: String) { println("LOG: About to save data") database.save(data) println("LOG: Save completed") } override fun load(id: Int): String? { println("LOG: About to load data with id $id") val result = database.load(id) println("LOG: Load completed") return result } } val realDb = RealDatabase() val loggingDb = LoggingDatabase(realDb) loggingDb.save("First record") loggingDb.save("Second record") println("Loaded: ${loggingDb.load(1)}") println("Loaded: ${loggingDb.load(99)}") // 8. Properties with setters in interfaces interface Configurable { var setting: String // Abstract property var description: String // Property with custom accessors get() = "Configurable with setting: $setting" set(value) { println("Description set to: $value") // Can't have backing field, but can store in implementing class } } class Configuration : Configurable { override var setting: String = "default" private var customDescription: String = "" override var description: String get() = customDescription set(value) { customDescription = "Custom: $value" } } val config = Configuration() config.setting = "production" config.description = "Production configuration" println(config.description) // 9. Interface with companion object interface Factory { companion object { fun create(): Factory { return object : Factory { override fun createInstance(): Any { return "Created instance" } } } } fun createInstance(): Any } val factory = Factory.create() println("Factory created: ${factory.createInstance()}") // 10. Resolving override conflicts with super interface A { fun foo() { println("A.foo") } fun bar() } interface B { fun foo() { println("B.foo") } fun bar() { println("B.bar") } } class C : A, B { // Must override foo() due to conflict override fun foo() { super.foo() // Call A's implementation super.foo() // Call B's implementation println("C.foo") } // Must override bar() even though B has default // (because A.bar() is abstract) override fun bar() { super.bar() // Can use B's default println("C.bar") } } val c = C() c.foo() c.bar() // 11. Interface as type interface Vehicle { fun drive() } class Car : Vehicle { override fun drive() { println("Car driving") } fun honk() { println("Beep beep!") } } class Bike : Vehicle { override fun drive() { println("Bike pedaling") } fun ringBell() { println("Ring ring!") } } fun testVehicle(vehicle: Vehicle) { vehicle.drive() // Can't call honk() or ringBell() here - only know it's a Vehicle } val vehicles: List = listOf(Car(), Bike()) for (vehicle in vehicles) { testVehicle(vehicle) // Type checks and smart casts when (vehicle) { is Car -> vehicle.honk() is Bike -> vehicle.ringBell() } } // 12. Read-only vs mutable properties in interfaces interface ReadOnly { val value: String // Read-only in interface fun getValue(): String } interface Mutable { var value: String // Mutable in interface fun setValue(newValue: String) } class Implementation : ReadOnly, Mutable { // Must implement both property declarations override var value: String = "" override fun getValue(): String { return "Value: $value" } override fun setValue(newValue: String) { value = newValue println("Value set to: $newValue") } } val impl = Implementation() impl.setValue("Test") println(impl.getValue()) println("\nInterfaces demonstration complete!") }