Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI

Tema3. Tipuri de funcţii (metode). Membrii statici și nestatici. Definirea constantelor. Excepţii: forma
de bază a tratării excepţiilor, instrucţiunea throw, throws. Blocurile try, catch, finally. Definirea
propriilor excepții.

Tipuri de metode
În Java există două tipuri de metode:
1) Metode care întorc un rezultat de un anumit tip, fie primitiv, fie referință. Se declară după sintaxa:
[modificatori] tipReturnat numeMetoda ([lista_argumente])
[throws tipExceptie1, tipExceptie2,...]{
// corpul metodei
return rez_tipReturnat;
}
Componența acestei sintaxe am discutat la lecțiile precedente, vom remarca faptul că 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. Vom examina câteva exemple:
Exemplul 1:
class Elev{
private int virsta=4;
int getVirsta() {
return virsta;
}
public static void main(String [] args) {
Elev e1= new Elev();
System.out.println(e1.getVirsta());
}
}
Dacă în Exemplul 1, atributul virsta va fi de tip double va fi
generată următoarea eroare de compilare:
Exemplul 2:
class Operatii{
double impartire(int a1, int a2) {
return (a1+a2)/2;
}
public static void main(String [] args) {
Operatii ob1 = new Operatii();
double rezultat = ob1.impartire(4, 1);
System.out.println(rezultat);
}}
Dacă analizați datele de intrare și ieșire în Exemplul 2, veți observa că operatorul / a returnat partea
întreagă de la împărțire, din motiv că operanzii sunt de tip int. Pentru a afișa întregul rezultat al
împărțirii se va realiza un cast la tipul double, ca în exemplul următor:
Exemplul 3:
class Operatii{
double impartire(int a1, int a2) {
return (double)(a1+a2)/2;
}
public static void main(String [] args) {
Operatii ob1 = new Operatii();
double rezultat = ob1.impartire(4, 1);
System.out.println(rezultat);
}}

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

1
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
Exemplul 4:
class Elev{
private int nrAbs;
String purtare() {
String x="";
if(this.nrAbs>=30)x="satisfacatoare";
else if (this.nrAbs<30&&this.nrAbs>=20)x="buna";
else if (this.nrAbs<20&&this.nrAbs>=8)x="foarte buna";
else x="excelenta";
return x;
}
public static void main(String [] args) {
Elev e1= new Elev();
e1.nrAbs=0;
System.out.println("Elevul are purtare " + e1.purtare());
} }
2) Metode care nu întorc rezultat. Mai sunt numite metode void, se utilizează pentru a realiza diverse
inițializări, sau pentru a afișa anumite date la ecran:
Exemplul 5:
class Elev{
private int nrAbs;
void setNrAbs(int x) {
nrAbs=x;
}
void afiseaza(){
System.out.println("Elevul are "+nrAbs+" absente");
}}
class TestElev{
public static void main(String [] args) {
Elev e1= new Elev();
e1.setNrAbs(3);
e1.afiseaza();
} }

Membri statici
O clasă Java poate conține următorii membri statici:
a) atribut. Dacă un atribut este static, el aparține clasei. Deci pentru a apela un astfel de atribut se
va respecta sintaxa NumeClasa.numeAtributStatic.
Exemplul 6:
class ClasaMea{
static int variabilaStatica=6;
int variabilaDeInstanta;

public static void main(String [] args) {

ClasaMea ob1 = new ClasaMea();
ob1.variabilaDeInstanta=4;
int suma=ob1.variabilaDeInstanta+ClasaMea.variabilaStatica;
System.out.println(suma);
}}

Pentru variabilele statice sistemul alocă o singură zonă de memorie la care au acces toate
obiectele clasei respective:

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

2
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
Exemplul 7:
class Exe_Static{
static int a;
int A;
public static void main(String [] args) {
Exe_Static ob1 = new Exe_Static();
ob1.A=5;
ob1.a=5;
System.out.println("ob1: a="+Exe_Static.a +", A="+ob1.A);
System.out.println("===================================");
Exe_Static ob2 = new Exe_Static();
ob2.A=10;
ob2.a=7;
System.out.println("ob1: a="+Exe_Static.a +", A="+ob1.A);
System.out.println("ob2: a="+Exe_Static.a +", A="+ob2.A);
System.out.println("===================================");
}}
b) metodă. Metodele statice, la fel ca atributele statice, aparțin clasei și vor fi apelate printr-o
construcție de forma: NumeClasa.numeMetodaStatica.
Exemplul 8:
class Met_Static{
static int suma(int n) {
int s=0;
for (int i=1; i<=n;i++) s+=i;
return s;
}
public static void main(String [] args) {
System.out.println("Suma este " + Met_Static.suma(5));
}}
c) bloc de inițializare. (vezi Fișa Laborator Nr.2)
O clasă nu poate avea modificatorul non-acces static în declarația acesteia. După cum am menționat la
una din lecțiile anterioare, o clasă poate conține alte declarații de clase în interiorul acestora numite
clase interne. Clasele interne pot fi statice.
Rețineți! 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 accessa orice membri nestatic din
context static:

Definirea constantelor
Pentru a defini o constantă în Java se va folosi cuvintele rezervate public static final, public pentru a
putea fi accesată de orinde, static pentru ca să fie acceași valoare pentru toate obiectele, final pentru
ca să nu poată fi modificată valoarea. Rețineți! Conform Convenției de Programare, identificatorii de
constante se scriu cu majuscule.
Exemplul 9:
class Persoana{
public static final int PICIOARE=2;
public static void main(String[] arg) {
System.out.println("Persoana are "+Persoana.PICIOARE+" picioare");
}}
opreavictoria86@gmail.com © MUSTEAȚĂ Victoria
3
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
Ce sunt excepțiile?
Procesul de programare este mereu însoțit de diverse probleme legate de viitorul soft. Programatorului
îi revine misiunea de a prezice care sunt aceste probleme ce pot apărea în procesul execuției software-
ului și de a reduce la minim apariția acestora.
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 care 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, ș.a.

Java pune la dispoziția programatorilor clasa Throwable din care sunt extinse toate celelalte excepții, şi
care face parte din următoarea ierarhie:

Tipuri de excepții
Clasa Object este părintele tuturor claselor Java.
Clasa Throwable împarte excepțiile în 2 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 (ex. fișier absent, date de intrare nevalide,
probleme ce țin de baze de date, ș.a).
Dacă un oarecare cod dintr-o metodă ar putea genera o astfel de excepție atunci este obligatoriu de
a oferi un mecanism de tratate a acesteia fie prin try...catch fie cu ajutorul cuvântul 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ă, ș.a). Acestea deasemenea pot fi tratate, însă
la discreția programatorului.
În Java excepțiile derivate din clasele Error și RuntimeException sunt excepții neverificate (unchecked),
orice altă clasă de excepție derivată din Throwable este verificată (checked).

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

4
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
Instanțele clasei Error reprezintă erori interne, nerecuperabile, ale mediului de lucru Java. Aceste erori
sunt rare şi de obiecei fatale; nu le putem intercepta, însă există pentru ca Java să le poată folosi dacă
are nevoie de ele.
Iata câteva excepții predefinite ale limbajului Java:
Verificate Neverificate
FileNotFoundException ArithmeticException
Absența unui fișier Eroare de tip aritmetic, de exemplu împărțire la zero.
IOException ArrayIndexOutOfBoundsException
Eroare din cauza operațiilor de intrare ieșire Indexul din sir este în afara limitelor
SQLException NumberFormatException
Eroare de accesare serverului SQL Conversia dintr-un string într-un numar a eșuat.
ClassNotFoundException NullPointerException
Eroare de încărcare a clasei în memorie Folosirea obiectului neinstanțiat (egal cu null).

Metode de tratare a 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ătură metodei:
De exemplu:
public static void main(String [] args) throws FileNotFoundException {
// corpul metodei ce conține codul ce poate genera excepții
}
2) folosind blocurile try ... catch...finally:
Blocul try blochează toate instrucțiunile ce pot genera excepții. Are sintaxa :
try{
// instrucțiuni ce pot genera excepții
}
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.
Blocul catch este blocul în care sunt tratate excepțiile. Are sintaxa :
catch (ClasaDeExceptii numeVariabila{
/ / instrucţiuni de tratare
}
ClasaDeExceptii reprezintă clasa excepției tratate. numeVariabila este o variabilă cu ajutorul căreia
putem accesa metodele clasei excepției tratate. Deseori cu această variabilă nu se lucrează dar şi

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

5
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
în acest caz ea trebuie declarată obligatoriu altfel obținem eroare sintactică 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 însoțit de orice număr de blocuri catch.
Exemplul 10:
Fără tratarea excepțiilor Cu tratarea excepțiilor
class ex2 { class ex1 {
public static void main (String [] public static void main (String [] args){
args){ int [] s={1,2,3,4};
int [] s={1,2,3,4}; try {
System.out.println(s[6]); System.out.println(s[6]);
System.out.println(s[0]); }catch (IndexOutOfBoundsException ex){
System.out.println("Nu avem asa indice pentru tablou!");
}} } System.out.println(s[0]);
}

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 {
// instrucțiuni executate indiferent
}

Instrucțiunea try...catch...finally are următoarea formă completă :

try {
... //instructiuni ce pot genera exceptii
} catch (TipExceptie1 ex){
... // instructiuni pentru tratarea exceptiei de tip TipExceptie1
}
catch (TipExceptie2 ex){
... // instructiuni pentru tratarea exceptiei de tip TipExceptie2
}finally{
... // instructiuni executate indiferent de ce se intimpla in blocul try
}
Exemplu 12:
class exe6 {
public static void main(String [] args){
int x= (int)(Math.random()*5);
int y= (int)(Math.random()*8);
int [] z={1,2,3,4,5};
try {
System.out.println("Sau generat numerel : "+x+" "+y);
System.out.println("x/y este "+x/y);
System.out.println("y="+y+"z[y]="+z[y]);
}catch (ArithmeticException e1 ){
System.out.println("problema aritmetica : Impartire la 0");
opreavictoria86@gmail.com © MUSTEAȚĂ Victoria
6
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
}catch (IndexOutOfBoundsException e2){
System.out.println("depasire de index"+e2);
}finally { System.out.println("Elaborat de mine !");
}}}

Rezultat :

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ă. Această instrucțiune poate fi folosită în următoarele situații:
a) Fără a defini o clasă proprie de excepții:
import java.util.InputMismatchException;
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 InputMismatchException();
}catch (InputMismatchException e) {
System.out.println("Introduceti un numar pozitiv");
}}}
b) Cu definirea propriei clase de excepții. Pentru aceasta este suficient de a definiti o clasa derivată
din Exception. Clasele derivate de utilizator nu trebuie sa 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;
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);
}}

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

7
Programarea Orientată spre Obiecte, Limbajul Java, 2019-2020 CEITI
Rețineți ! 1. Cu ajutorul cuvântului rezervat throw avem posibilitatea de a crea explicit un tip de
excepție propriu, adică putem crea o instanță excepție, arunca și trata la faza de
execuție. Se folosește nemijlocit însoțită de blocul try și operatorul new().
2. Cuvântul rezervat throws ne ajută atunci când dorim să aruncăm, sau transferăm
eroarea, astfel încât aceasta să fie tratată de compilator automat, adică eroarea nu
va fi tratată de noi explicit într-un bloc try. Cuvîntul rezervat throws se scrie în
semnătura metodei codul căreia ar putea genera o excepție. Acesta va fi urmat de
tipul erorii sau tipurile erorilor ce pot fi generate și deasemenea se poate folosi în
semnătura metodei main().

Întrebări și exerciții

1. Explicați necesitatea tratării excepțiilor la programarea aplicațiilor.

2. Explicați cum veți înlătura apariția erorilor sintactice, semantice și de execuție.
3. Numiți cuvintele rezervate folosite la tratarea excepțiilor.
4. Este necesar ca fiecare bloc try să fie urmat de un bloc catch?
5. Poate un bloc finally folosit fără blocul catch?
6. Care este diferența dintre cuvintele rezervate throw și throws ?
7. Cercetați următoarea secvență de cod Java. Preziceți situațiile excepționale ce ar putea să fie
generate în momentul execuției acesteia:
public static long Factorial(int n){
if (n == 0)
return 1;
else return n * Factorial(n - 1);
}
8. Numiți tipul de excepție ce va fi generat la execuția secvenței de cod :
public class Test {
public static void main (String [] args ) {
System.out.println( 1 / 0 ) ;
}
}
9. Numiți tipul de excepție ce va fi generat la execuția secvenței de cod :
public class Test {
public static void main (String [] args ) {
Object o = null;
System.out.println( o.toString() ) ;
}
}

Surse:
1. http://www.aut.upt.ro/~adrianaa/teaching/PJis/Lucrarea%206.pdf
2. http://users.utcluj.ro/~igiosan/Resources/POO/Curs/POO07.pdf
3. http://facultate.solidsoftsolutions.com/tutorials/CursJava/fisiere/f11.html
4. http://grail.cba.csuohio.edu/~matos/notes/cis-265/lecture-notes/03-13slide-Exceptions.pdf
5. http://www.cs.ucv.ro/staff/dtusaliu/dar/curs/limbajuljava/cap23.html
6. https://docs.oracle.com/javase/tutorial/essential/exceptions/

opreavictoria86@gmail.com © MUSTEAȚĂ Victoria

8