Curs 3
Exceptii
Ce sunt exceptiile ?
Avantajele exceptiilor
"Prinderea" si tratarea exceptiilor (Instructiunile try-catch-finally)
"Aruncarea" exceptiilor (Clauza throws, Instructiunea throw)
Ierarhia claselor ce descriu exceptii (Clasa Throwable)
Exceptii la executie
Crearea propriilor exceptii
Ce sunt exceptiile?
Termenul exceptie este o prescurtare pentru "eveniment exceptional" si poate fi definit astfel:
Definitie
O exceptie este un eveniment ce se produce în timpul executiei unui program si care provoaca întreruperea cursului normal al executiei.
Exceptiile pot aparea din diverse cauze si pot avea nivele diferite de gravitate: de la erori fatale cauzate de echipamentul hardware pâna la erori ce tin strict de codul programului, cum ar fi accesarea unui element din afara spatiului alocat unui vector. In momentul când o asemenea eroare se produce în timpul executiei sistemul genereaza automat un obiect de tip exceptie ce contine:
informatii despre exceptia respectiva
starea programului în momentul producerii acelei exceptii
public class Exceptii {
public static void main(String argsst) {
int v[] = new int[10];
v[10] = 0; //exceptie, vectorul are elementele v[0]...v[9]
System.out.println("Aici nu se mai ajunge...");
}
}
La rularea programului va fi generata o exceptie si se va afisa mesajul :
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException :10
at Exceptii.main (Exceptii.java:4)
Crearea unui obiect de tip exceptie se numeste aruncarea unei exceptii ("throwing an exception"). In momentul în care o metoda genereaza o exceptie (arunca o exceptie) sistemul de executie este responsabil cu gasirea unei secvente de cod dintr-o metoda care sa trateze acea exceptie. Cautarea se face recursiv, începând cu metoda care a generat exceptia si mergând înapoi pe linia apelurilor catre acea metoda.
Secventa de cod dintr-o metoda care trateaza o anumita exceptie se numeste analizor de exceptie ("exception handler") iar interceptarea si tratarea exceptie se numeste prinderea exceptiei ("catch the exception").
Cu alte cuvinte la aparitia unei erori este "aruncata" o exceptie iar cineva trebuie sa o "prinda" pentru a o trata. Daca sistemul nu gaseste nici un analizor pentru o anumita exceptie atunci programul Java se opreste cu un mesaj de eroare (în cazul exemplului de mai sus mesajul "Aici nu se mai ajunge..." nu va fi tiparit).
Atentie: In Java tratarea erorilor nu mai este o optiune ci o constrângere. Orice cod care poate provoca exceptii trebui sa specfice modalitatea de tratare a acestora.
Avantajele exceptiilor
Prin modalitatea sa de tratare a exceptiilor Java are urmatoarele avantaje fata de mecanismul traditional de tratare a erorilor:
Separarea codului pentru tratarea unei erori de codul în care ea poate sa apara
Propagarea unei erori pâna la un analizor de exceptii corespunzator
Gruparea erorilor dupa tipul lor
Separarea codului pentru tratarea unei erori de codul în care ea poate sa apara
In programarea traditionala tratarea erorilor se combina cu codul ce poate produce aparitia lor conducând la ada numitul "cod spaghetti". Sa consideram urmatorul exemplu: o functie care încarca un fisier în memorie:
citesteFisier {
deschide fisierul;
determina dimensiunea fisierului;
aloca memorie;
citeste fisierul in memorie;
inchide fisierul;
}
Problemele care pot aparea la aceasta functie, aparent simpla sunt de genul: "Ce se întâmpla daca: ... ?"
fisierul nu poate fi deschis
nu se poate determina dimensiunea fisierului
nu poate fi alocata suficienta memorie
nu se poate face citirea din fisier
fisierul nu poate fi închis
Un cod traditional care sa trateze aceste erori ar arata astfel:
int citesteFisier {
int codEroare = 0;
deschide fisier;
if (fisierul s-a deschis) {
determina dimensiunea fisierului;
if (s-a determinat dimensiunea) {
aloca memorie;
if (s-a alocat memorie) {
citeste fisierul in memorie;
if (nu se poate citi din fisier) {
codEroare = -1;
}
} else {
codEroare = -2;
}
} else {
codEroare = -3;
}
inchide fisierul;
if (fisierul nu s-a inchis && codEroare == 0) {
codEroare = -4;
} else {
codEroare = codEroare & -4;
}
} else {
codEroare = -5;
}
return codEroare;
}//cod "spaghetti"
Acest stil de progamare este extrem de susceptibil la erori si îngreuneaza extrem de mult întelegerea sa.
In Java, folosind mecansimul exceptiilor, codul ar arata astfel:
int citesteFisier {
try {
deschide fisierul;
determina dimensiunea fisierului;
aloca memorie;
citeste fisierul in memorie;
inchide fisierul;
}
catch (fisierul nu s-a deschis) {trateaza eroarea;}
catch (nu s-a determinat dimensiunea) {trateaza eroarea;}
catch (nu s-a alocat memorie) {trateaza eroarea }
catch (nu se poate citi dun fisier) {trateaza eroarea;}
catch (nu se poate inchide fisierul) {trateaza eroarea;}
}
Propagarea unei erori pâna la un analizor de exceptii corespunzator
Sa presupunem ca apelul la metoda citesteFisier este consecinta unor apeluri imbricate de metode:
int metoda1 {
apel metoda2;
. . .
}
int metoda2 {
apel metoda3;
. . .
}
int metoda3 {
apel citesteFisier;
. . .
}
Sa presupunem de asemenea ca dorim sa facem tratarea erorilor doar în metoda1. Traditional, acest lucru ar trebui facut prin propagarea erorii întoarse de metoda citesteFisier pâna la metoda1.
int metoda1 {
int codEroare = apel metoda2;
if (codEroare != 0)
proceseazaEroare;
. . .
}
int metoda2 {
int codEroare = apel metoda3;
if (codEroare != 0)
return codEroare;
. . .
}
int metoda3 {
int codEroare = apel citesteFisier;
if (codEroare != 0)
return codEroare;
. . .
}
Java permite unei metode sa arunce exceptiile aparute în cadrul ei la un nivel superior, adica functiilor care o apeleaza sau sistemului. Cu alte cuvinte o metoda poate sa nu îsi asume responsabilitatea tratarii exceptiilor aparute în cadrul ei:
metoda1 {
try {
apel metoda2;
}
catch (exceptie) {
proceseazaEroare;
}
. . .
}
metoda2 throws exceptie{
apel metoda3;
. . .
}
metoda3 throws exceptie{
apel citesteFisier;
. . .
}
Gruparea erorilor dupa tipul lor
In Java exista clase corespunzatoare tuturor exceptiilor care pot aparea la executia unui program. Acestea sunt grupate în functie de similaritatile lor într-o ierarhie de clase. De exemplu, clasa IOException se ocupa cu exceptiile ce pot aparea la operatii de intrare/iesire si diferentiaza la rândul ei alte tipuri de exceptii, cum ar fi FileNotFoundException, EOFException, etc.
La rândul ei clasa IOException se încadreaza într-o categorie mai larga de exceptii si anume clasa Exception. Radacina acestei ierarhii este clasa Throwable (vezi "Ierarhia claselor ce descriu exceptii").
Interceptarea unei exceptii se poate face fie la nivelul clasei specifice pentru acea exceptie fie la nivelul uneia din superclasele sale, în functie de necesitatile programului:
try {
FileReader f = new FileReader("input.dat");
//acest apel poate genera exceptie de tipul FileNotFoundException
//tratarea ei poate fi facuta in unul din modurile de mai jos
}
catch (FileNotFoundException e) {
//exceptie specifica provocata de absenta fisierului 'input.dat'
} //sau
catch (IOException e) {
//exceptie generica provocata de o operatie de intrare/iesire
} //sau
catch (Exception e) {
//cea mai generica exceptie - NERECOMANDATA!
}
"Prinderea" si tratarea exceptiilor
Tratarea exceptiilor se realizeaza prin intermediul blocurilor de instructiuni try, catch si finally. O secventa de cod care trateaza anumite exceptii trebuie sa arate astfel:
try {
Instructiuni care pot genera o exceptie
}
catch (TipExceptie1 ) {
Prelucrarea exceptiei de tipul 1
}
catch (TipExceptie2 ) {
Prelucrarea exceptiei de tipul 2
}
. . .
finally {
Cod care se executa indiferent daca apar sau nu exceptii
}
Sa consideram urmatorul exemplu : citirea unui fisier si afisarea lui pe ecran. Fara a folosi tratarea exceptiilor codul programului ar arata astfel:
//ERONAT!
import java.io.*;
public class CitireFisier {
public static void citesteFisier() {
FileInputStream sursa = null; //s este flux de intrare
int octet;
sursa = new FileInputStream("fisier.txt");
octet = 0;
//citesc fisierul caracter cu caracter
while (octet != -1) {
octet = sursa.read();
System.out.print((char)octet);
}
sursa.close();
}
public static void main(String args[]) {
citesteFisier();
}
}
Acest cod va furniza erori la compilare deoarece în Java tratarea erorilor este obligatorie.
Folosind mecanismul exceptiilor metoda citesteFisier îsi poate trata singura erorile pe care le poate provoca:
//CORECT
import java.io.*;
public class CitireFisier {
public static void citesteFisier() {
FileInputStream sursa = null; //s este flux de intrare
int octet;
try {
sursa = new FileInputStream("fisier.txt");
octet = 0;
//citesc fisierul caracter cu caracter
while (octet != -1) {
octet = sursa.read();
System.out.print((char)octet);
}
catch (FileNotFoundException e) {
System.out.println("Fisierul nu a fost gasit !");
System.out.println("Exceptie: " + e.getMessage());
System.exit(1);
}
catch (IOException e) {
System.out.println("Eroare de intrare/iesire");
System.out.println("Exceptie: " + e.getMessage());
System.exit(2);
}
finally {
if (sursa != null) {
System.out.println("Inchidem fisierul...");
try {
sursa.close();
}
catch (IOException e) {
System.out.println("Fisierul poate fi inchis!");
System.out.println("Exceptie: " + e.getMessage());
System.exit(3);
}
}
}
}
public static void main(String args[]) {
citesteFisier();
}
}
Blocul "try" contine instructiunile de deschidere a unui fisier si de citire dintr-un fisier ambele putând produce exceptii. Exceptiile provocate de aceste instructiuni sunt tratate în cele doua blocuri "catch", câte unul pentru fiecare tip de exceptie.
Inchiderea fisierului se face în blocul "finally", deoarece acesta este sigur ca se va executa. Fara a folosi blocul "finally" închiderea fisierului ar fi trebuit facuta în fiecare situatie în care fisierul ar fi fost deschis, ceea ce ar fi dus la scrierea de cod redundant:
try {
. . .
sursa.close();
}
. . .
catch (IOException e) {
. . .
sursa.close(); //cod redundant
}
Atentie: Obligatoriu un bloc de instructiuni "try" trebuie sa fie urmat de unul sau mai multe blocuri "catch", în functie de exceptiile provocate de acele instructiuni sau (optional) de un bloc "finally"
"Aruncarea" exceptiilor
In cazul în care o metoda nu îsi asuma responsabilitatea tratarii uneia sau mai multor exceptii pe care le pot provoca anumite instructiuni din codul sau atunci ea poate sa "arunce" aceste exceptii catre metodele care o apeleaza, urmând ca acestea sa implementeze tratarea lor sau, la rândul lor, sa "arunce" mai departe exceptiile respective.
Acet lucru se realizeaza prin specificarea în declaratia metodei a clauzei throws:
metoda throws TipExceptie1, TipExceptie2, ... {
. . .
}
Atentie: O metoda care nu trateaza o anumita exceptie trebuie obligatoriu sa o "arunce". In exemplul de mai sus daca nu facem tratarea exceptiilor în cadrul metodei citesteFisier atunci metoda apelanta (main) va trebui sa faca acest lucru:
import java.io.*;
public class CitireFisier {
public static void citesteFisier() throws FileNotFoundException, IOException {
FileInputStream sursa = null; //s este flux de intrare
int octet;
sursa = new FileInputStream("fisier.txt");
octet = 0;
//citesc fisierul caracter cu caracter
while (octet != -1) {
octet = sursa.read();
System.out.print((char)octet);
}
sursa.close();
}
public static void main(String args[]) {
try {
citesteFisier();
}
catch (FileNotFoundException e) {
System.out.println("Fisierul nu a fost gasit !");
System.out.println("Exceptie: " + e.getMessage());
System.exit(1);
}
catch (IOException e) {
System.out.println("Eroare de intrare/iesire");
System.out.println("Exceptie: " + e.getMessage());
System.exit(2);
}
}
}
Observati ca, în acest caz, nu mai putem diferentia exceptiile provocate de citirea din fisier si de închiderea fisierului ambele fiind de tipul IOException.
Aruncarea unei exceptii se poate face si implicit prin instructiunea throw ce are formatul: throw obiect_de_tip_Exceptie .
Exemple:
throw new IOException();
if (index >= vector.length)
throw new ArrayIndexOutOfBoundsException();
catch(Exception e) {
System.out.println("A aparut o exceptie);
throw e;
}
Aceasta instructune este folosita mai ales la aruncarea exceptiilor proprii care, evident, nu sunt detectate de catre mediul de executie. (vezi "Crearea propriilor exceptii")
Ierarhia claselor ce descriu exceptii
Radacina claselor ce descriu exceptii este clasa Thowable iar cele mai importante subclase ale sale sunt Error, Exception si RuntimeException, care sunt la rândul lor superclase pentru o serie întreaga de tipuri de exceptii.
Clasa Error
Erorile (obiecte de tip Error) sunt cazuri speciale de exceptii generate de functionarea anormala a echipamentului hard pe care ruleaza un program Java si sunt invizibile programatorilor. Un program Java nu trebuie sa trateze aparitia acestor erori si este improbabil ca o metoda Java sa provoace asemenea erori.
Clasa Exception
Obiectele de acest tip sunt exceptiile standard care trebuie tratate de catre programele Java. In Java, tratarea exceptiilor nu este o optiune ci o constrângere.
Exceptiile care pot "scapa" netratate sunt încadrate în subclasa RuntimeException si se numesc exceptii la executie.
In general metodele care pot fi apelate pentru un obiect exceptie sunt definite în clasa Throwable si sunt publice, astfel încât pot fi apelate pentru orice tip de exceptie. Cele mai uzuale sunt: String getMessage( ) tipareste detaliul unei exceptii
void printStackTrace( ) tipareste informatii despre localizarea exceptiei
String toString( ) metoda din clasa Object, da reprezentarea ca sir de caractere a exceptiei
Exceptii la executie (RuntimeException)
In general tratarea exceptiilor este obligatorie în Java. De la acest principu se sustrag însa asa numitele exceptii la executie sau, cu alte cuvinte, exceptiile care pot proveni strict din vina programatorului si nu generate de o cauza externa.
Aceste exceptii au o superclasa comuna si anume RuntimeException si în acesata categorie sunt incluse:
operatii aritmetice (împartire la zero)
accesarea membrilor unui obiect ce are valoarea null
operatii cu elementele unui vector (accesare unui index din afara domeniului,etc)
Aceste exceptii pot aparea uriunde în program si pot fi extrem de numeroare iar încercarea de "prindere" a lor ar fi extrem de anevoioasa. Din acest motiv compilatorul permite ca aceste exceptii sa ramâna netratate, tratarea lor nefiind însa ilegala.
int v[] = new int[10];
try {
v[10] = 0;
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Atentie la indecsi!");
e.printStackTrace();
}//legal
Crearea propriilor exceptii
Adeseori poate aparea necesitatea crearii unor exceptii proprii pentru a pune în evidenta cazuri speciale de erori provocate de clasele unei librarii, cazuri care nu au fost prevazute în ierarhia exceptiilor standard Java.
O exceptie proprie trebuie sa se încadreze în ierarhia exceptiilor Java, cu alte cuvinte clasa care o implementeaza trebuie sa fie subclasa a unei clase deja existente în aceasta ierarhie, preferabil una apropiata ca semnificatie sau superclasa Exception.
class MyException extends Exception {
public MyException() {}
public MyException(String msg) {
super(msg);
//apeleaza constructorul superclasei Exception
}
}
Un exemplu de folosire a exceptiei nou create:
public class TestMyException {
public static void f() throws MyException {
System.out.println("Exceptie in f()");
throw new MyException();
}
public static void g() throws MyException {
System.out.println("Exceptie in g()");
throw new MyException("aruncata din g()");
}
public static void main(String[] args) {
try {
f();
} catch(MyException e) {e.printStackTrace();}
try {
g();
} catch(MyException e) {e.printStackTrace();}
}
}
Fraza cheie este extends Exception care specifica faptul ca noua clasa MyEception este subclasa a clasei Exception si deci implementeaza obiecte ce reprezinta exceptii.
In general codul adaugat claselor pentru exceptii proprii este nesemnificativ: unul sau doi constructori care afiseaza un mesaj de eroare la iesirea standard.
Rularea programului de mai sus va produce urmatorul rezultat:
Exceptie in f()
MyException()
at TestMyException.f(TestMyException.java:12)
at TestMyException.main(TestMyException.java:20)
Exceptie in g()
MyException(): aruncata din g
at TestMyException.g(TestMyException.java:16)
at TestMyException.main(TestMyException.java:23)
Procesul de creare a unei noi exceptii poate fi dus mai departe prin adaugarea unor noi metode clasei ce descrie acea exceptie, însa aceasta dezvoltare nu îsi are rostul în majoritatea cazurilor. In general, exceptiile proprii sunt descrise de clase foarte simple chiar fara nici un cod în ele, cum ar fi:
class SimpleException extends Exception { }
Aceasta clasa se bazeaza pe constructorul implicit creat de compilator însa nu are constructorul SimpleException(String), care în practica nici nu este prea des folosit.
