Explică cum funcționează cuvântul cheie 'super' în…

Cuvântul cheie super este utilizat pentru a accesa membrii (proprietăți, metode) clasei părinte din clasa copil.

Principalele moduri de utilizare:

Apelarea constructorului clasei părinte: Este adesea folosit în constructorul clasei copil pentru a apela constructorul corespunzător al părintelui. Acest lucru este obligatoriu dacă clasa părinte are un constructor primar cu parametri.
```
open class Parent(val name: String)

class Child(name: String) : Parent(name) {
    // Constructorul Child apelează constructorul Parent,
    // transmitând parametrul name.
}
```

Accesul la membrii clasei părinte, suprascrisi în clasa copil: Permite accesul la implementarea unei metode sau proprietăți în clasa părinte, chiar dacă au fost suprascrise (cu override) în clasa copil.

open class Base {
    open fun greet() {
        println("Hello from Base")
    }

    open val value: Int = 1
}

class Derived : Base() {
    override fun greet() {
        super.greet() // Apelul la greet() din Base
        println("Hello from Derived")
    }

    override val value: Int = 2
        get() {
            println("Accesarea valorii Derived")
            return super.value + 1 // Acces la value din Base
        }
}

Accesul la membrii unui tip superior specific (în cazul moștenirii multiple de interfețe): Dacă o clasă implementează mai multe interfețe care au membri cu aceleași nume, super împreună cu specificarea numelui interfeței în paranteze unghiulare (super<TypeName>) permite indicarea clară a membrului de care interfață se face referire.

interface MyInterface1 {
    fun foo() { println("MyInterface1 foo") }
}

interface MyInterface2 {
    fun foo() { println("MyInterface2 foo") }
}

class MyClass : MyInterface1, MyInterface2 {
    override fun foo() {
        super<MyInterface1>.foo() // Apelul la foo() din MyInterface1
        super<MyInterface2>.foo() // Apelul la foo() din MyInterface2
    }
}

Explică cum funcționează cuvântul cheie 'super' în limbajul Kotlin.