Explicit 'this' or 'super' call is required. There is no constructor in the superclass that can be called without arguments
Subclasa are un constructor secundar care nu apelează constructorul clasei părinte, iar părintele nu are constructor fără argumente. Adaugă apelul după semnătură: constructor(nume: String, rasa: String) : super(nume) { ... }.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Orice obiect al unei subclase trebuie să inițializeze întâi partea din clasa părinte. Când subclasa nu are constructor primar (class Caine : Animal { ... }, fără paranteze), fiecare constructor secundar trebuie să spună singur cum se construiește părintele: : super(...) sau, prin alt constructor al aceleiași clase, : this(...).
Dacă nu scrii nimic, Kotlin încearcă să apeleze constructorul fără argumente al părintelui. Când acesta nu există (de exemplu open class Animal(val nume: String)), primești Explicit 'this' or 'super' call is required. There is no constructor in the superclass that can be called without arguments.
De cele mai multe ori, soluția mai simplă în Kotlin este un constructor primar: class Caine(nume: String, val rasa: String) : Animal(nume). Constructorii secundari cu super(...) apar mai ales când extinzi clase Java (de exemplu excepții sau view-uri Android) cu mai multe variante de construcție.
De ce apare: cauzele frecvente
1Constructor secundar fără super
class Caine : Animal {
constructor(nume: String, rasa: String) {
this.rasa = rasa
}
}class Caine : Animal {
constructor(nume: String, rasa: String) : super(nume) {
this.rasa = rasa
}
}: super(nume) dă părintelui argumentul de care are nevoie.
2Constructor secundar în loc de primar
class Caine : Animal {
val rasa: String
constructor(nume: String, rasa: String) { this.rasa = rasa }
}class Caine(nume: String, val rasa: String) : Animal(nume)Cu un constructor primar, părintele se inițializează direct în lista de supertipuri.
3Excepție proprie cu mai mulți constructori
class EroareStoc : Exception {
constructor(mesaj: String) { }
}class EroareStoc : Exception {
constructor(mesaj: String) : super(mesaj)
}Fără super(mesaj), mesajul nu ajunge la Exception (aici există constructor fără argumente, dar mesajul s-ar pierde).
Repară eroarea, direct în pagină
Clasa Caine are un constructor secundar care nu inițializează partea din Animal, iar Animal cere un nume, deci compilarea se oprește cu Explicit 'this' or 'super' call is required. Dă numele mai departe părintelui ca programul să afișeze Rex (labrador).
open class Animal(val nume: String)
class Caine : Animal {
val rasa: String
constructor(nume: String, rasa: String) {
this.rasa = rasa
}
}
fun main() {
val c = Caine("Rex", "labrador")
println("${c.nume} (${c.rasa})")
}Rex (labrador)
Indiciu
Apelul la constructorul părintelui se scrie după semnătură: : super(...).
Reparația
open class Animal(val nume: String)
class Caine : Animal {
val rasa: String
constructor(nume: String, rasa: String) : super(nume) {
this.rasa = rasa
}
}
fun main() {
val c = Caine("Rex", "labrador")
println("${c.nume} (${c.rasa})")
}De ce merge
Un Caine este și un Animal, deci înainte de corpul constructorului trebuie construit părintele. Animal are un singur constructor, care cere nume. Constructorul secundar nu-l apela, iar Kotlin nu avea un constructor fără argumente la care să recurgă. : super(nume) îi transmite numele, iar apoi corpul inițializează rasa.
Alte forme ale mesajului
error: explicit 'this' or 'super' call is required. There is no constructor in the superclass that can be called without arguments.Explicit 'this' or 'super' call is required. There is no constructor in superclass that can be called without arguments
Cum o eviți pe viitor
Preferă constructorul primar și pune apelul la părinte în declarația clasei: class Caine(nume: String) : Animal(nume). Pentru variante de construcție folosește valori implicite ale parametrilor în loc de mai mulți constructori secundari. Când chiar ai constructori secundari, începe fiecare cu : super(...) sau : this(...).
Întrebări frecvente
Care e diferența dintre this(...) și super(...)?
super(...) apelează un constructor al clasei părinte. this(...) apelează alt constructor al aceleiași clase, care la rândul lui ajunge la părinte.
De ce în Java nu primeam eroarea?
Primeai una echivalentă: constructor Animal in class Animal cannot be applied to given types, pentru că Java inserează automat super() fără argumente.
Erori înrudite
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. Primary constructor call expected Clasa are un constructor primar (parametrii de după numele clasei), iar un constructor secundar nu îl apelează. Fiecare constructor secundar trebuie să delege la cel primar: constructor(nume: String) : this(nume, 0) { ... }. 'val' on secondary constructor parameter is prohibited Ai scris val sau var la un parametru din constructor(...), constructorul secundar. Doar parametrii constructorului primar (cel de lângă numele clasei) pot deveni proprietăți. Scoate val din constructorul secundar și declară proprietatea în clasă sau în constructorul primar. Î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.
