Kā darbojas mantošana Kotlin?

Kotlin manto princips balstīts uz atvērtu klasu principu. Noklusējuma režīmā visas klases ir slēgtas (finals), un, lai padarītu klasi mantošanu, to skaidri jānorāda ar atslēgas vārdu open.

Galvenie punkti:

Atvērtas klases: Vecāku klasei jābūt atzīmētai kā open.
```
open class Base {
    // ...
}
```
Mantošana: Mantošana tiek veikta ar divpunkti (:), pēc kura seko vecāku klases nosaukums un, ja nepieciešams, tās konstruktora izsaukums.
```
class Derived : Base() {
    // ...
}
```
Metodēm un īpašībām pārrakstīšana: Lai pārrakstītu vecāku klases metodes vai īpašības, tās jānorāda kā open, un mantošanas klasē jālieto override vārds.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Ja vecāku metode vai īpašība nav atzīmēta kā open, to pārrakstīt nav iespējams.

Piekļuve vecāku klases locekļiem: Piekļuve vecāku klases locekļiem no mantošanas klases tiek veikta ar super vārdu.

class Derived : Base() {
    override fun process() {
        super.process() // Vecāku klases metodes izsaukums
        // ...
    }
}

Konstruktori: Ja vecāku klasei ir parametrus saturošs konstruktors, mantošanas klasei tas jāizsauc savā deklarācijā.

open class Base(name: String) {
    // ...
}

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

Saskarnes: Klase var realizēt vairākas saskarnes, kuras var norādīt pēc mantošanas klases, atdalītas ar komatu. Saskarnes pēc noklusējuma ir "atvērtas" realizācijai.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstraktas klases: Abstraktas klases tiek izmantotas daļējas realizācijas noteikšanai un satur abstraktus metodes un īpašības (abstract), kuras jārealizē mantošanas klasēs. Abstraktas locekļi neprasa open. Abstrakta klase arī neprasa open mantošanai.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Kopumā Kotlin tiecas uz skaidrību, pieprasot open lietošanu mantošanai un pārrakstīšanai.