Functional interface must have exactly one abstract function
Ai declarat o fun interface care are zero sau mai multe funcții abstracte. O interfață funcțională (folosită cu lambda) trebuie să aibă exact una. Dă corp celorlalte funcții (implementare implicită) sau scoate fun din declarație.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
fun interface declară o interfață care se poate implementa direct cu o lambda (conversie SAM): val v = Validator { it.isNotBlank() }. Ca lambda să știe ce funcție implementează, interfața trebuie să aibă exact o funcție abstractă. Dacă are două sau niciuna, compilatorul raportează Functional interface must have exactly one abstract function pe cuvântul fun.
După prima eroare apar de obicei altele, în lanț, pe locurile unde folosești lambda: Interface 'fun interface Validator' does not have constructors și Unresolved reference 'it'. Ele dispar când repari declarația.
Funcțiile cu corp (implementări implicite) și proprietățile cu getter nu contează: poți avea oricâte, atât timp cât rămâne o singură funcție abstractă. Proprietățile abstracte nu sunt permise deloc într-o fun interface.
De ce apare: cauzele frecvente
1Două funcții abstracte
fun interface Validator {
fun valid(x: String): Boolean
fun mesaj(): String
}fun interface Validator {
fun valid(x: String): Boolean
fun mesaj(): String = "valoare invalida"
}Cu un corp implicit, mesaj nu mai e abstractă, iar lambda implementează doar valid.
2Interfață fără nicio funcție abstractă
fun interface Marcajinterface MarcajO interfață de marcare nu are ce implementa cu o lambda; nu are nevoie de fun.
3Ai nevoie de mai multe operații
fun interface Repo {
fun salveaza(p: String)
fun sterge(p: String)
}interface Repo {
fun salveaza(p: String)
fun sterge(p: String)
}
class RepoMemorie : Repo {
override fun salveaza(p: String) {}
override fun sterge(p: String) {}
}Pentru mai multe operații, folosește o interfață obișnuită și o clasă (sau un object) care o implementează.
Repară eroarea, direct în pagină
Interfața funcțională Regula are două funcții abstracte, iar codul nu compilează: Functional interface must have exactly one abstract function. Dă funcției descriere() o implementare implicită care întoarce "regula", ca programul să afișeze regula: true, false.
fun interface Regula {
fun verifica(parola: String): Boolean
fun descriere(): String
}
fun main() {
val lungime = object : Regula {
override fun verifica(parola: String) = parola.length >= 8
}
println("${lungime.descriere()}: ${lungime.verifica("kotlin2025")}, ${lungime.verifica("abc")}")
}regula: true, false
Indiciu
O funcție cu corp nu mai e abstractă: fun descriere(): String = "regula".
Reparația
fun interface Regula {
fun verifica(parola: String): Boolean
fun descriere(): String = "regula"
}
fun main() {
val lungime = object : Regula {
override fun verifica(parola: String) = parola.length >= 8
}
println("${lungime.descriere()}: ${lungime.verifica("kotlin2025")}, ${lungime.verifica("abc")}")
}De ce merge
O fun interface există ca să poată fi implementată cu o lambda, deci trebuie să aibă exact o funcție abstractă; cu două, compilatorul a refuzat declarația. Cu un corp implicit pentru descriere(), singura funcție abstractă rămasă este verifica. Obiectul din main o implementează, iar la fel de bine ai putea scrie acum Regula { it.length >= 8 }.
Alte forme ale mesajului
error: functional interface must have exactly one abstract function.Fun interfaces must have exactly one abstract methodFun interface must have exactly one abstract method
Cum o eviți pe viitor
Folosește fun interface doar pentru tipuri cu o singură operație (validatoare, handlere, strategii, callback-uri). Dacă interfața crește și are nevoie de o a doua operație, decide conștient: fie îi dai o implementare implicită, fie renunți la fun și implementezi cu clase. Pentru callback-uri simple, un tip funcțional ((String) -> Boolean) e adesea suficient.
Întrebări frecvente
Care e diferența față de un tip funcțional (String) -> Boolean?
fun interface are un nume propriu, poate avea funcții implicite și poate fi implementată și de clase. Tipul funcțional e mai simplu, dar fără nume și fără alte metode.
Interfețele Java cu o singură metodă trebuie marcate?
Nu. Interfețele Java SAM (Runnable, Comparator) acceptă lambda direct. fun interface e necesar doar pentru interfețele declarate în Kotlin.
Erori înrudite
This type does not have a constructor Ai pus paranteze după o interfață în lista de supertipuri (class Cerc : Forma()). Interfețele nu au constructor, deci nu se apelează: scrie doar numele, class Cerc : Forma. Parantezele se pun doar după clasa părinte. 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ă. Property initializers in interfaces are prohibited Ai dat o valoare (= ...) unei proprietăți dintr-o interfață. Interfețele nu au câmpuri, deci nu pot stoca valori. Folosește un getter (val x: Int get() = 4), lasă proprietatea abstractă și dă valoarea în clase, sau folosește o clasă abstractă. Î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.
