This type is final, so it cannot be extended
Încerci să moștenești o clasă care nu e marcată open. În Kotlin, clasele sunt implicit final, adică nu pot avea subclase. Adaugă open în fața clasei părinte (open class Animal), sau abstract dacă nu vrei obiecte din ea direct.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Spre deosebire de Java, în Kotlin orice clasă este final dacă nu spui altfel: nu poate fi moștenită. E o alegere de design: moștenirea trebuie să fie o decizie explicită a celui care scrie clasa. Când scrii class Caine : Animal() și Animal nu e open, primești This type is final, so it cannot be extended la numele clasei părinte.
În Kotlin 1.x mesajul era This type is final, so it cannot be inherited from.
Aceeași regulă se aplică metodelor: o funcție poate fi suprascrisă doar dacă e open (sau abstract), altfel primești 'sunet' in 'Animal' is final and cannot be overridden. Clasele abstract, sealed și interfețele sunt deschise implicit pentru moștenire. data class nu poate fi open: dacă ai nevoie de o ierarhie, folosește o sealed class sau o interfață ca părinte.
De ce apare: cauzele frecvente
1Clasă părinte fără open
class Animal(val nume: String)
class Caine(nume: String) : Animal(nume)open class Animal(val nume: String)
class Caine(nume: String) : Animal(nume)open permite subclase. Fără el, Animal e final.
2Moștenire dintr-o data class
data class Produs(val nume: String)
class Carte(nume: String) : Produs(nume)abstract class Produs(val nume: String)
class Carte(nume: String) : Produs(nume)data class e mereu finală. Pentru o ierarhie, părintele e o clasă abstract / open sau o interfață.
Repară eroarea, direct în pagină
Programul de mai jos dă eroarea This type is final, so it cannot be extended. Repară clasa Angajat ca să poată fi moștenită (și metoda ei să poată fi suprascrisă), astfel încât programul să afișeze Ana: 5000 și Ion: 6500.
class Angajat(val nume: String) {
fun salariu(): Int = 5000
}
class Manager(nume: String) : Angajat(nume) {
override fun salariu(): Int = 6500
}
fun main() {
val echipa = listOf(Angajat("Ana"), Manager("Ion"))
for (a in echipa) println("${a.nume}: ${a.salariu()}")
}Ana: 5000 Ion: 6500
Indiciu
Marchează cu open atât clasa Angajat, cât și funcția salariu.
Reparația
open class Angajat(val nume: String) {
open fun salariu(): Int = 5000
}
class Manager(nume: String) : Angajat(nume) {
override fun salariu(): Int = 6500
}
fun main() {
val echipa = listOf(Angajat("Ana"), Manager("Ion"))
for (a in echipa) println("${a.nume}: ${a.salariu()}")
}De ce merge
Angajat era finală (implicit în Kotlin), deci Manager nu o putea extinde. open class permite moștenirea, iar open fun salariu() permite suprascrierea; fără al doilea open, ai fi primit 'salariu' in 'Angajat' is final and cannot be overridden. În buclă, apelul a.salariu() alege versiunea potrivită pentru fiecare obiect (polimorfism).
Alte forme ale mesajului
This type is final, so it cannot be inherited fromerror: this type is final, so it cannot be extended.'sunet' in 'Animal' is final and cannot be overridden
Cum o eviți pe viitor
Când proiectezi o clasă de bază, decide de la început: abstract class (nu creezi obiecte direct din ea, doar din subclase), open class (poți crea și obiecte din ea) sau interface (doar comportament). Marchează open și metodele pe care subclasele au voie să le suprascrie. Pentru stări sau rezultate cu un număr fix de variante, sealed class e cea mai bună alegere.
Întrebări frecvente
De ce Kotlin face clasele final implicit?
Moștenirea necontrolată face codul fragil: o schimbare în clasa părinte poate strica subclasele. Kotlin te obligă să marchezi explicit ce e gândit pentru extindere.
Trebuie să pun open și pe metode?
Da, dacă vrei să le suprascrii. Clasa open permite subclase, dar metodele rămân finale până le marchezi open. În clasele abstract, metodele abstract sunt deschise automat.
Erori înrudite
'sunet' hides member of supertype 'Animal' and needs an 'override' modifier Ai scris în subclasă o funcție (sau proprietate) cu același nume și aceiași parametri ca una din clasa părinte, dar fără override. Kotlin nu permite suprascrierea „pe ascuns”. Adaugă override în fața ei (și open la funcția din părinte, dacă nu e deja). This type has a constructor, so it must be initialized here Moștenești o clasă, dar ai scris numele ei fără paranteze (class Caine : Animal). O clasă părinte cu constructor trebuie apelată la moștenire: class Caine : Animal(), cu argumentele cerute de constructorul ei între paranteze. Class 'Cerc' is not abstract and does not implement abstract member: fun arie(): Double Clasa ta implementează o interfață sau moștenește o clasă abstractă, dar nu scrie una dintre funcțiile (sau proprietățile) abstracte cerute; mesajul spune care: fun arie(): Double. Adaugă override fun arie(): Double = ... în clasă. Învață Kotlin de la zero, cu exerciții la fiecare lecție
Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
