Kotlin'da meros olish qanday ishlaydi?

Kotlin'da merosxo'rlik ochiq sinflar tamoyiliga asoslangan. Standart tarzda, barcha sinflar yopiq (final) bo'lib, ularni merosxo'rlik qilish uchun aniq open so'z bilan belgilash kerak.

Asosiy nuqtalar:

Ochiq sinflar: Asosiy sinf open bilan belgilanishi kerak.
```
open class Base {
    // ...
}
```
Merosxo'rlik: Merosxo'rlik ikki nuqta (:) yordamida amalga oshiriladi, undan keyin asosiy sinf nomi va agar kerak bo'lsa, uning konstruktor chaqiriladi.
```
class Derived : Base() {
    // ...
}
```
Metod va xususiyatlarni qayta yozish: Asosiy sinfdan metod yoki xususiyatlarni qayta yozish uchun, ular open bilan belgilangan bo'lishi kerak, va meros sinfda override so'zi ishlatiladi.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Agar asosiy sinfdan metod yoki xususiyat open bilan belgilangan bo'lmasa, uni qayta yozib bo'lmaydi.

Asosiy sinf a'zolariga kirish: Asosiy sinf a'zolariga meros sinfidan kirish super so'zi yordamida amalga oshiriladi.

class Derived : Base() {
    override fun process() {
        super.process() // Asosiy sinf metodini chaqirish
        // ...
    }
}

Konstruktorlar: Agar asosiy sinf parametrli konstruktorga ega bo'lsa, meros sinf bu konstruktorni o'zining imzosida chaqirishi kerak.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfeyslar: Bir sinf bir nechta interfeyslarni amalga oshirishi mumkin, va ular vergul bilan ajratilgan holda meros sinfdan keyin ko'rsatiladi (agar mavjud bo'lsa). Interfeyslar odatda "ochiq" bo'lib, amalga oshirish uchun.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstrakt sinflar: Abstrakt sinflar qisman amalga oshirishni belgilash uchun ishlatiladi va ular abstract bilan belgilangan metodlar va xususiyatlarni o'z ichiga oladi, ular meros sinflar tomonidan amalga oshirilishi kerak. Abstrakt a'zolar open talab qilmaydi. Abstrakt sinf ham open bo'lish shart emas.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

class AbsDerived : AbsBase() {
    override fun abstractMethod() { /* ... */ }
}
```

Umuman olganda, Kotlin aniq bo'lishga intilmoqda va open foydalanishni merosxo'rlik va qayta yozish uchun talab qiladi.