error: incompatible types: SoldInsuficient cannot be converted to Throwable
Ai aruncat cu throw (sau prins cu catch) o clasă care nu e excepție, pentru că nu extinde Exception sau RuntimeException. Adaugă extends Exception (sau extends RuntimeException) la declarația clasei tale.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
throw și catch acceptă doar obiecte de tip Throwable, adică excepții și erori. O clasă devine excepție doar dacă extinde, direct sau indirect, Exception, RuntimeException sau Error. Dacă ai creat class SoldInsuficient { } și o arunci, compilatorul nu are ce să facă cu ea: SoldInsuficient cannot be converted to Throwable.
Alegerea părintelui contează:
extends Exceptionface o excepție verificată: metodele care o aruncă trebuie să o declare cuthrows, iar apelanții trebuie să o trateze;extends RuntimeExceptionface o excepție neverificată, care nu trebuie declarată.
Ca mesajul să ajungă în getMessage(), adaugă un constructor care primește textul și îl trimite mai departe cu super(mesaj). Mesajul de eroare apare și la catch (SoldInsuficient e), dacă clasa nu e excepție.
De ce apare: cauzele frecvente
1Clasa excepției fără extends
class SoldInsuficient {
}
throw new SoldInsuficient();class SoldInsuficient extends Exception {
SoldInsuficient(String mesaj) { super(mesaj); }
}
throw new SoldInsuficient("Sold prea mic");extends Exception o face excepție, iar super(mesaj) păstrează textul pentru getMessage().
2Ai aruncat un text
throw "Sold insuficient";throw new IllegalStateException("Sold insuficient");În Java nu poți arunca un String. Folosești o excepție, standard sau proprie, cu mesajul în constructor.
3Ai moștenit din clasa greșită
class EmailInvalid extends Object {
}
catch (EmailInvalid e) { }class EmailInvalid extends RuntimeException {
EmailInvalid(String m) { super(m); }
}
catch (EmailInvalid e) { }Doar descendenții lui Throwable pot fi prinși în catch.
Repară eroarea, direct în pagină
Programul aruncă o excepție proprie la retragerea unei sume mai mari decât soldul, dar nu compilează: SoldInsuficient cannot be converted to Throwable. Fă din SoldInsuficient o excepție, ca programul să afișeze Retras: 50, sold 50 și Refuzat: sold insuficient (50).
public class Main {
static class SoldInsuficient {
SoldInsuficient(String mesaj) {
}
}
static int sold = 100;
static void retrage(int suma) throws SoldInsuficient {
if (suma > sold) {
throw new SoldInsuficient("sold insuficient (" + sold + ")");
}
sold -= suma;
System.out.println("Retras: " + suma + ", sold " + sold);
}
public static void main(String[] args) {
try {
retrage(50);
retrage(80);
} catch (SoldInsuficient e) {
System.out.println("Refuzat: " + e.getMessage());
}
}
}Retras: 50, sold 50 Refuzat: sold insuficient (50)
Indiciu
Clasa trebuie să extindă Exception și să trimită mesajul la super(mesaj).
Reparația
public class Main {
static class SoldInsuficient extends Exception {
SoldInsuficient(String mesaj) {
super(mesaj);
}
}
static int sold = 100;
static void retrage(int suma) throws SoldInsuficient {
if (suma > sold) {
throw new SoldInsuficient("sold insuficient (" + sold + ")");
}
sold -= suma;
System.out.println("Retras: " + suma + ", sold " + sold);
}
public static void main(String[] args) {
try {
retrage(50);
retrage(80);
} catch (SoldInsuficient e) {
System.out.println("Refuzat: " + e.getMessage());
}
}
}De ce merge
throw, throws și catch lucrează doar cu descendenți ai lui Throwable. Cu extends Exception, SoldInsuficient devine o excepție verificată, deci throws SoldInsuficient și catch au sens. super(mesaj) păstrează textul, iar getMessage() îl întoarce. Prima retragere reușește, a doua (80 din 50) este refuzată.
Alte forme ale mesajului
error: incompatible types: String cannot be converted to Throwableerror: incompatible types: EmailInvalid cannot be converted to Throwable
Cum o eviți pe viitor
- Numește clasele excepțiilor cu sufixul
Exception(SoldInsuficientException): așa se vede imediat ce trebuie să extindă. - Scrie de la început constructorul cu mesaj și
super(mesaj). - Alege
RuntimeExceptionpentru greșeli de programare sau validări, șiExceptioncând apelantul chiar trebuie să trateze situația. - Înainte să creezi o excepție nouă, vezi dacă una standard (
IllegalArgumentException,IllegalStateException) nu spune deja ce vrei.
Întrebări frecvente
Exception sau RuntimeException pentru excepția mea?
Dacă vrei ca fiecare apelant să fie obligat să trateze situația (de exemplu fonduri insuficiente), Exception. Dacă e o greșeală pe care codul corect n-ar trebui s-o facă (argument invalid), RuntimeException. În multe proiecte moderne, mai ales cu Spring, se preferă RuntimeException.
De ce getMessage() îmi întoarce null?
Pentru că nu ai trimis mesajul la părinte. Constructorul excepției trebuie să apeleze super(mesaj).
Erori înrudite
error: unreported exception Exception; must be caught or declared to be thrown Apelezi o metodă care poate arunca o excepție verificată (checked), iar codul tău nici nu o prinde, nici nu o declară. Pune apelul într-un try/catch sau adaugă throws NumeExceptie la metoda care face apelul. error: exception EmailInvalid has already been caught Ai un catch pentru o excepție mai generală (de exemplu Exception sau IOException) înaintea unui catch pentru o subclasă a ei. Blocul al doilea n-ar rula niciodată. Pune catch-urile de la cel mai specific la cel mai general. error: cannot find symbol Compilatorul nu găsește un nume folosit în cod: o variabilă, o metodă sau o clasă. De obicei e o greșeală de scriere, o variabilă declarată în alt bloc sau un import lipsă; liniile symbol și location din mesaj îți spun exact ce lipsește. Învață Java de la zero, cu exerciții la fiecare lecție
Curs Java: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
