Multiple supertypes available. Specify the intended supertype in angle brackets, e.g. 'super<Foo>'.
Ai scris super.functie() într-o clasă care moștenește două tipuri (interfețe sau clasă + interfață) care au amândouă funcția. Kotlin nu știe pe care o vrei: precizează cu super<NumeTip>.functie().
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
O clasă Kotlin poate implementa mai multe interfețe, iar fiecare poate avea o implementare implicită pentru aceeași funcție. În override, super.descriere() devine ambiguu: din Camera sau din Agenda? Compilatorul raportează Multiple supertypes available. Specify the intended supertype in angle brackets, e.g. 'super<Foo>'.
Reparația e chiar în mesaj: scrii super<Camera>.descriere() sau super<Agenda>.descriere(), sau pe amândouă, combinate.
Eroarea apare de obicei imediat după ce ai rezolvat Class 'X' must override 'descriere' because it inherits multiple interface methods for it: ai adăugat override-ul, dar în corp ai lăsat un super. fără tip. Aceeași situație apare și cu o clasă de bază și o interfață care au același membru.
De ce apare: cauzele frecvente
1super fără tip cu două interfețe
interface A { fun f() = "A" }
interface B { fun f() = "B" }
class C : A, B {
override fun f() = super.f()
}interface A { fun f() = "A" }
interface B { fun f() = "B" }
class C : A, B {
override fun f() = super<A>.f() + super<B>.f()
}super<A> și super<B> aleg explicit implementarea dorită.
2Clasă de bază și interfață cu același membru
open class Baza { open fun log() = "baza" }
interface Jurnal { fun log() = "jurnal" }
class Serviciu : Baza(), Jurnal {
override fun log() = super.log()
}open class Baza { open fun log() = "baza" }
interface Jurnal { fun log() = "jurnal" }
class Serviciu : Baza(), Jurnal {
override fun log() = super<Baza>.log()
}Și aici există două implementări moștenite; numește tipul din care o vrei.
Repară eroarea, direct în pagină
Clasa Telefon implementează Camera și Gps, ambele cu descriere(), iar override-ul folosește super.descriere() și nu compilează: Multiple supertypes available. Repară override-ul ca să combine ambele descrieri și programul să afișeze camera 50MP + gps.
interface Camera { fun descriere() = "camera 50MP" }
interface Gps { fun descriere() = "gps" }
class Telefon : Camera, Gps {
override fun descriere() = super.descriere() + " + " + super.descriere()
}
fun main() {
println(Telefon().descriere())
}camera 50MP + gps
Indiciu
Folosește super<Camera>.descriere() și super<Gps>.descriere().
Reparația
interface Camera { fun descriere() = "camera 50MP" }
interface Gps { fun descriere() = "gps" }
class Telefon : Camera, Gps {
override fun descriere() = super<Camera>.descriere() + " + " + super<Gps>.descriere()
}
fun main() {
println(Telefon().descriere())
}De ce merge
Telefon moștenește două implementări ale lui descriere(), una din Camera și una din Gps. Un super.descriere() simplu nu spune pe care o vrei, de aceea compilatorul a cerut tipul între paranteze unghiulare. Cu super<Camera> și super<Gps>, fiecare apel își alege sursa, iar rezultatul le combină.
Alte forme ale mesajului
error: multiple supertypes available. Specify the intended supertype in angle brackets, e.g. 'super<Foo>'.Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super<Foo>'
Cum o eviți pe viitor
Când o clasă implementează mai multe interfețe cu implementări implicite pentru același membru, scrie mereu super<Tip> în override, chiar dacă la început ar fi un singur candidat: codul rămâne corect dacă adaugi încă o interfață. Evită numele de funcții foarte generice (log, descriere) în interfețe diferite, dacă nu sunt chiar același concept.
Întrebări frecvente
Pot apela super<Tip> pentru o interfață pe care nu o implementez direct?
Nu. Între <> pui doar supertipuri directe ale clasei, cele din lista de după :.
Și dacă doar una dintre interfețe are implementare?
Atunci super.f() nu mai e ambiguu (cealaltă e abstractă), dar super<Tip> rămâne mai clar și mai sigur la schimbări.
Erori înrudite
Class 'Telefon' must override 'descriere' because it inherits multiple interface methods for it Clasa implementează două interfețe care au aceeași metodă cu implementare implicită, iar Kotlin nu știe pe care s-o folosească. Suprascrie metoda în clasă și alege explicit: super<Camera>.descriere(), super<Agenda>.descriere() sau o combinație. Abstract member cannot be accessed directly Ai apelat super.functie() sau super.proprietate, dar în clasa părinte membrul e abstract, deci nu are implementare de apelat. Scrie implementarea direct în override, fără super, sau dă membrului un corp în clasa părinte (open în loc de abstract). Only one class can appear in a supertype list Clasa încearcă să moștenească două clase (class C : A(), B()). În Kotlin, ca în Java, poți extinde o singură clasă și oricâte interfețe. Transformă una dintre ele în interfață sau folosește compoziția: ține obiectul al doilea ca proprietate. Î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.
