¿Cómo funciona la herencia en Kotlin?

La herencia en Kotlin se basa en el principio de clases abiertas. Por defecto, todas las clases son cerradas (final), y para hacer una clase heredable, debe marcarse explícitamente con la palabra clave open.

Puntos clave:

Clases abiertas: La clase base debe estar marcada como open.
```
open class Base {
    // ...
}
```
Herencia: La herencia se realiza mediante dos puntos (:), seguidos del nombre de la clase base y, si es necesario, la llamada a su constructor.
```
class Derived : Base() {
    // ...
}
```
Sobrescritura de métodos y propiedades: Para sobrescribir métodos o propiedades de la clase base, estos deben estar marcados como open en la clase base, y en la clase derivada se usa la palabra clave override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Si el método o propiedad de la clase base no está marcado como open, no se puede sobrescribir.

Acceso a miembros de la clase base: El acceso a los miembros de la clase base desde la clase derivada se realiza mediante la palabra clave super.

class Derived : Base() {
    override fun process() {
        super.process() // Llamada al método de la clase base
        // ...
    }
}

Constructores: Si la clase base tiene un constructor con parámetros, la clase derivada debe llamar a ese constructor en su firma.

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

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

Interfaces: Una clase puede implementar varias interfaces, y estas se indican separadas por comas después de la clase base (si la hay). Las interfaces por defecto son "abiertas" para la implementación.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Clases abstractas: Las clases abstractas se usan para definir implementaciones parciales y contienen métodos y propiedades abstractas (marcadas con abstract) que deben ser implementadas en las clases derivadas. Los miembros abstractos no requieren open. La clase abstracta tampoco requiere open para ser heredada.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

En general, Kotlin busca la claridad, requiriendo el uso de open para permitir la herencia y la sobrescritura.