Come avviene l'ereditarietà nel linguaggio Kotlin?

L'ereditarietà in Kotlin si basa sulle parole chiave open e override. Le classi e i metodi sono final per impostazione predefinita, cioè non possono essere ereditati o sovrascritti. Per consentire l'ereditarietà, la classe o il metodo devono essere contrassegnati con il modificatore open.

Per creare una classe derivata, si utilizza due punti : dopo il nome della classe base, seguiti dal nome della classe base con il suo costruttore.

open class Base(val name: String) {
    open fun greet() {
        println("Ciao, $name")
    }
}

Per sovrascrivere un metodo della classe base nella classe derivata, si utilizza il modificatore override.

class Derived(name: String) : Base(name) {
    override fun greet() {
        println("Saluti, $name")
    }
}

Se la classe base ha un costruttore con parametri, la classe derivata deve chiamarlo usando la parola chiave super.

Kotlin supporta l'ereditarietà multipla di interfacce, ma non di classi. Una classe può ereditare solo da una classe.

Una classe può anche contrassegnare i propri membri come protected, internal o private, limitando la loro visibilità alle classi derivate o all'interno del modulo.

Le classi astratte si dichiarano con la parola chiave abstract. Possono contenere metodi astratti (senza implementazione) e metodi normali. I metodi astratti non necessitano della parola open, poiché si presume che vengano sovrascritti. Le classi astratte non possono essere istanziate direttamente.

abstract class Shape {
    abstract fun draw()
    open fun printInfo() {
        println("Questa è una forma.")
    }
}

In questo modo, l'ereditarietà in Kotlin è controllata esplicitamente tramite i modificatori open e override, migliorando la leggibilità e prevenendo ereditarietà indesiderate.