Working with Kotlin Object-Oriented Programming

class Student {
    var name: String = ""
    var grade: Int = 0

    fun displayInfo() {
        println("Name: $name, Grade: $grade")
    }
}

val student = Student()
student.name = "Alice"
student.grade = 90
student.displayInfo()

class Student(val id: Int, val name: String) {
    init {
        println("Student created with ID: $id")
    }
}

val student = Student(101, "Alice")

class Rectangle(val width: Double, val height: Double) {
    constructor(side: Double) : this(side, side)
}

val square = Rectangle(5.0)
val rectangle = Rectangle(4.0, 6.0)

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("initial") { _, old, new ->
        println("Name changed from $old to $new")
    }
}

fun main() {
    val user = User()
    user.name = "Alice" // Prints: Name changed from initial to Alice
}

class Rectangle(val width: Double, val height: Double) {
    val area: Double
        get() = width * height

    val perimeter: Double
        get() = 2 * (width + height)
}

fun main() {
    val rect = Rectangle(5.0, 3.0)
    println("Area: ${rect.area}") // Area: 15.0
    println("Perimeter: ${rect.perimeter}") // Perimeter: 16.0
}

class Person {
    var age: Int = 25 // Mutable property
        set(value) {
            if (value >= 0) field = value
        }

    val fullName: String = "John Doe" // Read-only property
}

fun main() {
    val person = Person()
    person.age = 30 // Valid
    // person.fullName = "Jane Doe" // Error: Val cannot be reassigned
}

open class Animal {
    open fun speak() {
        println("Animal speaks")
    }
}

class Dog : Animal() {
    override fun speak() {
        super.speak()
        println("Dog barks")
    }
}

fun main() {
    val dog = Dog()
    dog.speak()
}

abstract class Shape {
    abstract fun area(): Double
    open fun description(): String = "This is a shape"
}

class Circle(radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
    override fun description(): String = "This is a circle"
}

val circle = Circle(5.0)
println(circle.area()) // 78.53981633974483
println(circle.description()) // This is a circle

interface Drawable {<br>    fun draw()<br>}<br><br>class Circle : Drawable {<br>    override fun draw() {<br>        println("Drawing a circle")<br>    }<br>}

interface Flyable {<br>    fun fly()<br>}<br><br>interface Swimmable {<br>    fun swim()<br>}<br><br>class Duck : Flyable, Swimmable {<br>    override fun fly() {<br>        println("Duck flying")<br>    }<br><br>    override fun swim() {<br>        println("Duck swimming")<br>    }<br>}

class Person {
    private val id: String = "123"
    internal var name: String = "John"
    public fun getId(): String {
        return id
    }
}

class Employee : Person() {
    fun printName() {
        println(name) // Valid: internal property accessible in same module
        // println(id) // Invalid: private property not accessible
    }
}

data class Product(
    val id: Int,
    val name: String,
    val price: Double
)

val product1 = Product(1, "Laptop", 999.99)
val product2 = product1.copy(name = "Gaming Laptop")
val (id, name, price) = product1

println(product1) // Product(id=1, name=Laptop, price=999.99)
println(product2) // Product(id=1, name=Gaming Laptop, price=999.99)

fun describeColor(color: Color): String = when (color) {
    Color.RED -> "Red is for danger"
    Color.GREEN -> "Green is for go"
    Color.BLUE -> "Blue is for calm"
}

enum class Size(val width: Int, val height: Int) {
    SMALL(100, 100),
    MEDIUM(200, 200),
    LARGE(300, 300)
}

sealed class Result<T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val message: String) : Result<T>()
}

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

class OuterClass {
    private val outerProperty = "I'm from outer"

    class NestedClass {
        fun display() {
            println("Nested class accessing: $outerProperty") // ❌ Not possible
        }
    }

    inner class InnerClass {
        fun display() {
            println("Inner class accessing: $outerProperty") // ✅ Possible
        }
    }
}

fun main() {
    val outer = OuterClass()
    val nested = OuterClass.NestedClass()
    val inner = outer.InnerClass()

    nested.display() // Output: Nested class accessing: null
    inner.display()  // Output: Inner class accessing: I'm from outer
}

interface Drawable {<br>    fun draw(): Unit<br>}<br><br>class Canvas : Drawable {<br>    override fun draw() {<br>        println("Drawing on canvas")<br>    }<br>}<br><br>class Shape(delegatedDrawable: Drawable) : Drawable by delegatedDrawable<br><br>fun main() {<br>    val shape = Shape(Canvas())<br>    shape.draw() // Output: Drawing on canvas<br>}

import kotlin.properties.ReadWriteProperty<br>import kotlin.reflect.KProperty<br><br>class Delegate<T>(private var value: T) : ReadWriteProperty<Any?, T> {<br>    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value<br>    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {<br>        this.value = value<br>    }<br>}<br><br>class MyClass {<br>    var prop: String by Delegate("initial")<br>}<br><br>fun main() {<br>    val obj = MyClass()<br>    println(obj.prop) // Output: initial<br>    obj.prop = "updated"<br>    println(obj.prop) // Output: updated<br>}