გთხოვთ, ახსნათ, როგორ მუშაობს 'super' საკვანძო სიტყვა Kotlin ენისთვის.

საკვანძო სიტყვა super გამოიყენება მშობელ კლასის წევრებზე (მოძრაობებზე, მეთოდებზე) წვდომისთვის შვილობილი კლასიდან.

ძირითადი გამოყენების ვარიანტები:

1. მშობელ კლასის კონსტრუქტორის გამოძახება: ხშირად გამოიყენება შვილობილი კლასის კონსტრუქტორში მშობელ კონსტრუქტორის გამოძახებისთვის. ეს არის მნიშვნელოვანი, თუ მშობელ კლასს აქვს ძირითადი კონსტრუქტორი პარამეტრებით:

   open class Parent(val name: String)
   
   class Child(name: String) : Parent(name) {
       // Child-ის კონსტრუქტორი გამოძახებს Parent-ის კონსტრუქტორს,
       // გადაცემით name პარამეტრი:
   }
   

2. მშობელ კლასის გადაწერილი წევრებზე წვდომა: საშუალებას გაძლევთ მიმართოთ მშობელ კლასში მეთოდის ან თვისების რეალიზაციას, მიუხედავად იმისა, რომ ისინი გადაწერილია (override) შვილობილი კლასში:

   open class Base {
       open fun greet() {
           println("Hello from Base")
       }
   
       open val value: Int = 1
   }
   
   class Derived : Base() {
       override fun greet() {
           super.greet() // გამოძახება Base-ის greet()
           println("Hello from Derived")
       }
   
       override val value: Int = 2
           get() {
               println("Accessing Derived value")
               return super.value + 1 // წვდომა Base-ის value-ზე
           }
   }
   

3. კონკრეტული სუპერტიპის წევრებზე წვდომა (მრავალ ინტერფეისის მემკვიდრეობაში): თუ კლასი რეალიზებს რამდენიმე ინტერფეისს, რომლებიც აქვთ ერთნაირ სახელებსა და წევრებს, super და ინტერფეისის სახელის მითითება კუთხის ბრეკეტებში (super<TypeName>) საშუალებას აძლევს ზუსტად მიუთითოთ, რომელ წევრს უნდა მიმართოთ:

   interface MyInterface1 {
       fun foo() { println("MyInterface1 foo") }
   }
   
   interface MyInterface2 {
       fun foo() { println("MyInterface2 foo") }
   }
   
   class MyClass : MyInterface1, MyInterface2 {
       override fun foo() {
           super<MyInterface1>.foo() // გამოძახება MyInterface1-ის foo()
           super<MyInterface2>.foo() // გამოძახება MyInterface2-ის foo()
       }
   }