Tipuri de funcții(metode).

Membrii statici și
nestatici. Definirea constantelor.
Excepții.Blocurile
try,catch,finally.Definirea propriilor
excepții
profesor Dobrovolischii Olga
 Metode
1. Care întorc un rezultat de un anumit tip, fie primitiv, fie referință.
Așa tip de metodă conține ca tipReturnat un tip concret de date compatibil obligatoriu cu tipul valorii
returnate ca rezultat dată în identificatorul rez_tipReturnat

[modificatori] tipReturnat numeMetoda ([lista_argumente])

[throws tipExceptie1, tipExceptie2,...]{
//corpul metodei
return rez_tipReturnat;
}
Exemplu:
 Metode
2. Care nu întorc un rezultat
Metodele void, se utilizează pentru a realiza diverse inițializări, sau pentru a afișa
anumite date la ecran.
 Membri statici
Datele membre statice sunt date membre ale unei clase ce sunt partajate de toate obiectele.

Spre deosebire de datele membre obişnuite, datele membre statice nu aparţin fiecărui obiect al clasei, ci
există într-un singur exemplar comun tuturor obiectelor clasei respective.Se iniţializează automat cu
valoarea 0.

O clasă Java poate conține următorii membri statici:

 Membri statici
a) atribut Dacă un atribut este static , el aparține clasei. Pentru a apela un astfel de atribut se va
respecta sintaxa: NumeClasa.numeAtributStatic
 Membri statici
b) metode Metodele statice, la fel ca și atributele statice , aparțin clasei și vor fi apelate printr-o
construcție de forma: NumeClasa.numeMetodaStatica
c) blocurile de inițializare
➔ Dacă o metodă este statică nu veți putea apela în interiorul ei nimic din ceea ce NU este static.

Pentru aceasta trebuie să instanțiați clasa . Cu ajutorul instanței veți putea accesa orice membri nestatici
din context static:
 Definirea constantelor

O constantă este o variabilă a cărei valoare nu se poate modifica odată ce a fost atribuită. Java nu are
suport încorporat pentru constante, dar modificatorii variabili static și final pot fi folosiți pentru a crea unul
eficient.
Identificatorii de constante se scriu cu majuscule.
Modificator static
Acest lucru permite utilizarea unei variabile fără a crea mai întâi o instanță a clasei ; un membru de clasă
static este asociat cu clasa în sine, mai degrabă decât cu un obiect. Toate instanțele clasei partajează
aceeași copie a variabilei.
Aceasta înseamnă că o altă aplicație sau main () o poate folosi cu ușurință.
De exemplu, clasa myClass conține o variabilă statică days_in_week:
 Excepțiile
O excepție este un eveniment anormal ce apare în timpul execuției unui program și duce la oprirea
acestuia.

Procesul de izolare a situațiilor excepționale și controlul comportării aplicației în momentul apariției

acestora este numit tratarea excepțiilor.

O excepție poate fi generată din diverse motive :împărțirea la 0, deschiderea unui fișier cae nu există,
accesarea indexului unui tablou care depășește limitele acestuia , omiterea programării metodei main(),
accesarea unui obiect căruia nu i s-a oferit spațiu de memorie, etc..

Java pune la dispoziție clasa Throwable din care sunt extinse toate celelalte excepții, și care face parte
din următoarea ierarhie:
Excepțiile
 Excepțiile
Clasa Object este părintele claselor Java.

Clasa Throwable împarte excepțiile în două categorii:

➔ Verificate(checked): sunt excepții verificate la faza de compilare. Nu țin de algoritm, ci de anumite

condiții care ar putea afecta execuția programului. Dacă un oarecare cod dintr-o metodă ar putea
genera o astfel de excepție atunci este obligatoriu de a oferi un mecanism de tratare a acesteia fie
prin try...catch fie cu ajutorul cuvîntului rezervat throws, în caz contrar aplicația nu va putea fi
lansată la execuție.Programatorul este forțat să trateze așa tip de excepții.
➔ Neverificate(unchecked): sunt excepții care nu sunt verificate la faza de compilare ci generate la
faza de execuție, și sunt o consecință a neatenției programatorului la elaborarea
algoritmului(ex:împărțirea la 0, accesarea unui membru care nu există etc). Acestea deasemenea
pot fi tratate, însă la discreția programatorului
 Excepțiile

În Java excepțiile derivate din clasele Error și RuntimeException sunt excepții neverificate(unchecked),
orice altă clasă derivată din Throwable este verificată(checked).

Instanțele clasei Error reprezintă erori interne, nerecuperabile, ale mediului de lucru Java. Aceste erori
sunt rare și de obicei fatale; nu le putem intercepta , însă există pentru ca Java să le poată folosi dacă
are nevoie de ele.

Ex: OutOfMemoryError, VirtualMachineError, AssertionError etc.

 Excepțiile
Excepții predefinite ale limbajului Java:
Verificate Neverificate

FileNotFoundException ArithmeticException Eroare de tip aritmetic

Absența unui fișier

IOException ArrayIndexOutOfBoundsException
Eroare din cauza operațiilor de intrare/ieșire Indexul din șir este în afara limitelor

SQLException NumberFormatException
Eroare de accesare a serverului SQL Conversia dintr-un string într-un număr a eșuat

ClassNotFoundException NullPointerException
Eroare de încărcare a clasei de memorie Folosirea obiectului neinstanțiat(egal cu nul)
 Tratarea excepțiilor
Java , la fel ca alte limbaje de programare , oferă tehnici speciale ce permit interceptarea și tratarea
excepțiilor într-un mod standard și destul de comod.

În Java tratarea excepțiilor este obligatorie , orice secvență de cod ce poate provoca excepții trebuie să
fie însoțită și de o modalitate de tratare a acesteia:

1.declararea excepției în semnătura metodei

De exemplu:

public static void main(String[]args) throws FileNotFoundException{

//corpul metodei ce contine codul ce poate genera exceptii

}
 Tratarea excepțiilor
2. folosind blocurile try...catch...finally:
Blocul try blochează toate instrucțiunile ce pot genera excepții. Are sintaxa:

try{
//instructiuni ce pot genera exceptii
}

Rețineți:
❖ Un bloc try poate fi urmat fie de un bloc catch fie de un bloc finally, însă nu poate exista de unul
singur.
❖ Dacă instrucțiunile grupate de blocul try vor genera o excepție aceasta va fi tratată de blocul catch
corespunzător tipului de eroare aruncată(generată).
❖ Dacă instrucțiunile se vor executa cu succes nu se va mai ține cont de tratarea excepțiilor și
aplicația se va executa în mod normal.
 Tratarea excepțiilor
2. folosind blocurile try...catch...finally:

Blocul catch este blocul în care sunt tratate excepțiile. Are sintaxa:

catch (ClasaDeExceptii numeVariabila){

//instructiuni de tratare
}

ClasaDeExceptii reprezintă clasa excepției tratate. numeVariabilă este o variabilă cu ajutorul căreia putem
accesa metodele clasei excepției tratate. Deseori cu această variabilă nu se lucrează dar și în acest caz ea
trebuie declarată obligatoriu astfel obținem eroaresintactică precum că nu s-a respectat sintaxa instrucțiunii
catch.
Rețineți!
➢ Blocul catch Nu poate exista singur , ci doar însoțit de un bloc try
try{..} catch{...}
➢ Între blocul try și primul bloc catch nu pot exista alte instrucțiuni
➢ Un bloc try poate fi însotit de orice număr de blocuri catch
Observații:
❏ În cazul în care veți include codul ce poate genera excepții în blocul catch atunci programul va genera
eroare.
❏ În cazul în care la declararea blocului catch nu cunoașteți numele ClasaDeExceptii puteți indica numele
 Tratarea excepțiilor
2. folosind blocurile try...catch...finally:
Exemplu:
Fără tratarea excepțiilor Cu tratare excepțiilor

public class Ex_vector { public class Ex_exceptii {

public static void main(String[] args) {
public static void main(String[] args) { int[] s = { 1, 2, 3, 4 };
int[] s = { 1, 2, 3, 4 }; try {
System.out.println(s[6]);
System.out.println(s[0]); System.out.println(s[6]);
} } catch
Exercitiu: Fie avem următoarele declarații: (IndexOutOfBoundsException Ex_exceptii) {

public static void main(String[] args) {

System.out.println("nu avem asa indice pentru
int i = 50;
tablou!");
int j = 0;
}
Creați o clasă pentru a utiliza aceste declarații fără System.out.println(s[0]);
tratarea excepțiilor și o clasă cu tratarea excepțiilor. }

}
3.Blocul finally nu apare niciodată singur ci în asociere cu blocul try. Cuprinde codul care trebuie să se
execute indiferent dacă apar excepții în blocul try sau nu. Prin clauza finally instrucțiunea try...catch
devine completă. Acest bloc are sintaxa:

finally{
//instructiuni executate indiferent
}
Instrucțiunea try...catch...finally are următoarea formă completă:

try{
… // instructiuni ce pot genera exceptii
} catch(TipExceptie1 ex){
… // instructiuni pentru tratarea exceptiilor de tip TipExceptie1
}
catch (TipExceptie2 ex){
… //instructiuni pentru tratarea exceptiei de tip TipExceptie2
}finally{
… // instructiuni executate indiferent de ce se intimpla in blocul try
}
 Instrucțiunea Throw

Cu ajutorul instrucțiunii throw programatorul poate folosi modalități proprii de tratare a excepțiilor. De
obicei de acest lucru este nevoie atunci cînd apare o situație în care oricare excepție predefinită Java nu
este relevantă. Pentru aceasta este suficient de a defini o clasă derivată din Exception. Clasele derivate
de utilizator nu trebuie să implementeze nimic, simpla lor apartenență la ierarhia de tipuri permite
utilizarea lor ca excepții. Clasele create de utilizator dispun , prin moștenire, de proprietățile și metodele
definite de clasa Exception.
import java.util.InputMismatchException;
public class Exemp_Throw {
int nr = -1;
public static void main(String[] args) {
Exemp_Throw ob = new Exemp_Throw();
try {
if (ob.nr < 0)
throw new NumarNegativ("Fiti atenti");
} catch (NumarNegativ e) {
System.out.println("Introduceti un numar pozitiv”);
class NumarNegativ extends Exception {

NumarNegativ(String str) {
super(str);
}
}
Internal Working of Java Try-Catch