Conflicting overloads: fun f(a: Int): Int
Ai două funcții cu același nume și aceiași tipuri de parametri. Kotlin le deosebește doar după numărul și tipul parametrilor, nu după numele lor sau după tipul returnat. Redenumește una dintre funcții sau schimbă-i parametrii.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Overloading înseamnă mai multe funcții cu același nume, dar cu liste de parametri diferite: arie(latura: Double) și arie(l: Double, L: Double). Compilatorul alege funcția după argumentele de la apel. Ca să poată alege, semnăturile trebuie să difere prin numărul sau tipul parametrilor.
Mesajul Conflicting overloads apare când două declarații au aceeași semnătură: aceiași tipuri, în aceeași ordine. Nu contează că parametrii au alte nume (a vs b) și nici că funcțiile returnează tipuri diferite: la apelul f(1) nu ai cum să le deosebești. Compilatorul listează ambele declarații, iar la apeluri mai apare de obicei și Overload resolution ambiguity.
Se întâmplă des după un copy-paste sau când vrei două variante ale unei funcții care diferă doar prin rezultat (de exemplu Int și Double).
De ce apare: cauzele frecvente
1Diferă doar numele parametrilor
fun pret(net: Int) = net
fun pret(brut: Int) = brut * 119 / 100
fun main() {
println(pret(100))
}fun pretNet(net: Int) = net
fun pretBrut(net: Int) = net * 119 / 100
fun main() {
println(pretBrut(100))
}Numele parametrilor nu fac parte din semnătură. Două comportamente diferite merită două nume de funcție.
2Diferă doar tipul returnat
fun medie(l: List<Int>): Int = l.sum() / l.size
fun medie(l: List<Int>): Double = l.sum().toDouble() / l.size
fun main() {
println(medie(listOf(1, 2)))
}fun medie(l: List<Int>): Double = l.sum().toDouble() / l.size
fun main() {
println(medie(listOf(1, 2)))
}Tipul returnat nu deosebește două funcții. Păstrează o singură variantă (sau dă-le nume diferite).
Repară eroarea, direct în pagină
Programul de mai jos are două funcții arie cu același parametru și nu compilează: Conflicting overloads. Repară-l dând un nume potrivit fiecărei funcții, ca să afișeze Patrat: 16.0 și Cerc: 50.24.
fun arie(latura: Double) = latura * latura
fun arie(raza: Double) = 3.14 * raza * raza
fun main() {
println("Patrat: ${arie(4.0)}")
println("Cerc: ${arie(4.0)}")
}Patrat: 16.0 Cerc: 50.24
Indiciu
Redenumește funcțiile (de exemplu ariePatrat și arieCerc) și folosește noile nume la apel.
Reparația
fun ariePatrat(latura: Double) = latura * latura
fun arieCerc(raza: Double) = 3.14 * raza * raza
fun main() {
println("Patrat: ${ariePatrat(4.0)}")
println("Cerc: ${arieCerc(4.0)}")
}De ce merge
Ambele funcții se numeau arie și primeau un singur Double. Faptul că parametrii se numeau latura și raza nu contează, așa că semnăturile erau identice, iar la arie(4.0) nu se putea ști care e chemată. Cu nume diferite, fiecare apel e clar și fiecare formulă se aplică formei corecte.
Alte forme ale mesajului
error: conflicting overloads: fun f(b: Int): Int fun f(a: Int) = 1Conflicting overloads: public fun f(a: Int): Int defined in root package in file main.kt, public fun f(b: Int): Int defined in root package in file main.kt
Cum o eviți pe viitor
Folosește overloading doar când funcțiile fac același lucru pentru tipuri diferite de date. Când comportamentul diferă, alege nume diferite (pretNet, pretBrut). În Kotlin, de multe ori nici nu ai nevoie de overloading: parametrii cu valori implicite (fun pret(net: Int, tva: Int = 19)) înlocuiesc mai multe variante ale aceleiași funcții.
Întrebări frecvente
Pot avea fun f(x: Int) și fun f(x: Long)?
Da, tipurile diferă, deci e overloading valid. La apelul f(5) se alege varianta Int, iar la f(5L) varianta Long.
Ce legătură are cu Platform declaration clash?
Conflicting overloads apare când semnăturile sunt identice în Kotlin. Platform declaration clash apare când sunt diferite în Kotlin, dar ajung identice în bytecode-ul JVM.
Erori înrudite
Conflicting declarations: local val x: Int Ai declarat de două ori o variabilă cu același nume în același bloc (sau două proprietăți / funcții de nivel superior cu același nume). Șterge al doilea val/var și folosește atribuirea (x = ...) dacă voiai doar să schimbi valoarea, sau dă-i alt nume. Overload resolution ambiguity between candidates Există mai multe funcții cu același nume care se potrivesc la fel de bine cu apelul tău, iar compilatorul nu poate alege. Cazul tipic: f(null) când ai f(x: String?) și f(x: Int?). Fă apelul precis: dă tipul explicit (null as String?), folosește argumente cu nume sau redenumește una dintre funcții. Platform declaration clash: The following declarations have the same JVM signature (getName()Ljava/lang/String;) Două declarații diferite în Kotlin ajung la aceeași metodă în bytecode-ul JVM. Cazul clasic: proprietatea val name generează automat getName(), iar tu ai scris și o funcție getName(). Șterge funcția (folosește proprietatea) sau redenumește una dintre ele. Î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.
