Ինչպես է աշխատում ժառանգությունը Kotlin-ում?

Կոտլինում ժառանգությունը հիմնված է բաց դասերի սկզբունքի վրա: Դեպքում, բոլոր դասերը փակ են (final), և որպեսզի դասը ժառանգելի լինի, այն պետք է հստակ նշվի open բանալի բառով:

Հիմնական կետեր՝

• Բաց դասեր: Հայրական դասը պետք է նշվի որպես open:

  open class Base {
      // ...
  }
  

• Ժառանգություն: Ժառանգությունը կատարվում է : նշանի միջոցով, որի հետո նշվում է հայրական դասի անունը և, անհրաժեշտության դեպքում, նրա կոնստրուկտորի կանչը:

  class Derived : Base() {
      // ...
  }
  

• Մեթոդների և հատկությունների վերագրում: Հայրական դասի մեթոդներն ու հատկությունները պետք է նշվեն որպես open, իսկ ժառանգական դասում օգտագործվում է override բանալի բառը:

  open class Base {
      open fun process() { /* ... */ }
      open val value: Int = 0
  }
  
  class Derived : Base() {
      override fun process() { /* ... */ }
      override val value: Int = 1
  }
  

  Եթե հայրական մեթոդը կամ հատկությունը նշված չէ open, այն չի կարող վերագրել:
• Հայրական դասի անդամներին մուտք գործելը: Մուտք գործել հայրական դասի անդամներին ժառանգական դասից կատարվում է super բանալի բառով:

  class Derived : Base() {
      override fun process() {
          super.process() // Հայրական դասի մեթոդի կանչ
          // ...
      }
  }
  

• Կոնստրուկտորներ: Եթե հայրական դասի կոնստրուկտորը պարամետրեր ունի, ժառանգական դասը պետք է կանչի այդ կոնստրուկտորը իր հայտարարության մեջ:

  open class Base(name: String) {
      // ...
  }
  
  class Derived(name: String, age: Int) : Base(name) {
      // ...
  }
  

• Ինտերֆեյսներ: Դասը կարող է իրականացնել մի քանի ինտերֆեյսներ, որոնք նշվում են ժառանգվող դասից հետո, բաժանված ստորակետով: Ինտերֆեյսները ըստ նախնական կարգի "բաց" են իրականացման համար:

  interface MyInterface {
      fun doSomething()
  }
  
  class MyClass : Base(), MyInterface {
      override fun doSomething() { /* ... */ }
  }
  

• Աբստրակտ դասեր: Աբստրակտ դասերը օգտագործվում են մասամբ իրականացման սահմանման համար և պարունակում են աբստրակտ մեթոդներ և հատկություններ (նշված abstract), որոնք պետք է իրականացվեն ժառանգվող դասերում: Աբստրակտ անդամները չեն պահանջում open։ Աբստրակտ դասը նույնպես չի պահանջում open ժառանգության համար:

  abstract class AbsBase {
      abstract fun abstractMethod()
      open fun concreteMethod() { /* ... */ }
  }
  
  class AbsDerived : AbsBase() {
      override fun abstractMethod() { /* ... */ }
  }
  

Ընդհանուր առմամբ, Kotlin-ը ձգտում է հստակության, պահանջելով open օգտագործել ժառանգության և վերագրումների թույլտվության համար։