Como funciona a herança em Kotlin?

A herança em Kotlin baseia-se no princípio de classes abertas. Por padrão, todas as classes são fechadas (final), e para tornar uma classe herdável, ela deve ser explicitamente marcada com a palavra-chave open.

Pontos principais:

Classes abertas: A classe base deve ser marcada como open.
```
open class Base {
    // ...
}
```
Herança: A herança é feita usando dois pontos (:), seguidos do nome da classe base e, se necessário, a chamada ao seu construtor.
```
class Derived : Base() {
    // ...
}
```
Sobrescrita de métodos e propriedades: Para sobrescrever métodos ou propriedades da classe base, estes devem estar marcados como open na classe base, e na classe derivada usa-se a palavra-chave override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Se o método ou propriedade da classe base não estiver marcado como open, não pode ser sobrescrito.

Acesso aos membros da classe base: O acesso aos membros da classe base na classe derivada é feito com a palavra-chave super.

class Derived : Base() {
    override fun process() {
        super.process() // Chamada ao método da classe base
        // ...
    }
}

Construtores: Se a classe base tiver um construtor com parâmetros, a classe derivada deve chamar esse construtor na sua assinatura.

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

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

Interfaces: Uma classe pode implementar várias interfaces, e estas podem ser indicadas separando-as por vírgulas após a classe base (se houver). As interfaces por padrão são "abertas" para implementação.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Classes abstratas: Classes abstratas são usadas para definir implementação parcial e contêm métodos e propriedades abstratas (marcadas com abstract) que devem ser implementadas em classes derivadas. Membros abstratos não requerem open. Uma classe abstrata também não precisa ser marcada como open para ser herdada.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

No geral, Kotlin busca a clareza, exigindo o uso de open para permitir herança e sobrescrita.