java exceptions exception handling with examples
Acest tutorial video despre excepțiile Java explică totul despre gestionarea excepțiilor în Java. Veți afla despre ierarhia excepțiilor, tipurile, metodele de clasă și multe altele:
Când executăm programe Java, comportamentul normal sau fluxul normal al programului este întrerupt, din cauza unor evenimente neașteptate.
De exemplu, deschidem un fișier pentru citirea datelor. Când se execută apelul Deschidere fișier, găsim că lipsește fișierul pe care încercăm să îl deschidem. Acest lucru duce la întreruperea fluxului normal al programului.
Acest eveniment care afectează sau întrerupe fluxul normal al programului se numește „ Excepție ”.
=> Vizitați aici pentru a explora seria de antrenament Java pentru toți.
Iată un tutorial video despre gestionarea excepțiilor Java:
Ce veți învăța:
Manevrarea excepțiilor în Java
Când apare o excepție în program, execuția programului este încheiată. Deoarece aceasta este o încetare bruscă, sistemul generează un mesaj și îl afișează. Mesajul generat de sistem poate fi criptic precum unele coduri sau ilizibil.
Astfel, utilizatorul normal ar trebui să înțeleagă de ce programul a oprit brusc execuția sa, el / ea ar trebui să știe motivul. Este posibil ca mesajele generate de sistem ca urmare a excepției să nu fie de ajutor. În Java, putem gestiona excepția și putem oferi utilizatorilor mesaje semnificative despre această problemă.
Această gestionare a excepției, cunoscută în mod obișnuit ca „Manevrarea excepțiilor” este una dintre caracteristicile principale ale programării Java.
Motive pentru care apare excepția
Putem avea diverse motive din cauza cărora pot apărea excepții. Dacă este o excepție legată de intrare, atunci motivul poate fi că datele de intrare sunt incorecte sau ilizibile.
Dacă obținem o excepție pentru I / O fișier, atunci este foarte posibil ca fișierele cu care avem de-a face să nu existe. În alte momente, pot exista erori precum probleme de rețea, imprimanta nu este disponibilă sau nu funcționează etc.
Într-un program, în afară de excepții, primim și erori. Astfel, pentru a gestiona excepțiile în mod eficient, trebuie să fim conștienți de diferențele dintre eroare și o excepție.
O eroare indică o problemă mai gravă cu aplicația și aplicația nu ar trebui să încerce să o prindă. Dimpotrivă, excepția este o condiție pe care orice aplicație rezonabilă va încerca să o prindă.
Astfel, o eroare în aplicație este mai severă, iar aplicațiile se blochează atunci când întâmpină o eroare. Excepțiile, pe de altă parte, apar în cod și pot fi gestionate de programator oferind acțiuni corective.
Ce este gestionarea excepțiilor?
Exception Handling in Java este un mecanism prin care se menține fluxul normal al aplicației. Pentru a face acest lucru, folosim un mecanism puternic pentru a gestiona erorile de runtime sau excepțiile dintr-un program.
O secvență de cod care este utilizată pentru a gestiona excepția se numește „Exception handler”. Un handler de excepție interogează contextul în momentul în care a avut loc excepția. Aceasta înseamnă că citește valorile variabilei care erau în domeniu în timp ce a avut loc excepția și apoi restabilește programul Java pentru a continua cu fluxul normal.
Avantajele manipulării excepțiilor
Avantajul major al gestionării excepțiilor este că menține fluxul normal al aplicației în ciuda apariției unei excepții. Când apare o excepție, programul se termină de obicei brusc.
A avea un handler de excepție într-un program nu va determina terminarea bruscă a programului. În schimb, un gestionar de excepții se asigură că toate instrucțiunile din program sunt executate în mod normal și fluxul programului nu se întrerupe brusc.
Ierarhie de excepție în Java
Diagrama de mai jos prezintă ierarhia de excepții în Java. Clasa java.lang.Throwable (descendentă a clasei Object) este clasa rădăcină a Java Exception. Clasele Exception și Error sunt derivate din această clasă.
Clasa de excepții este clasa de bază pentru toate celelalte excepții.
Mai jos este prezentată o ierarhie a clasei Exception în Java care va enumera toate excepțiile majore pe care ar trebui să le cunoască un programator Java.
Clasa de excepție în Java
Așa cum se vede în diagrama ierarhiei, clasa Throwable are două subclase directe, adică Excepție și Eroare. Excepțiile care decurg dintr-o sursă externă sunt descrise în clasa Excepții.
Clasa Exception declară constructorii la fel ca clasa Throwable și invocarea fiecărui constructor invocă și omologul său Throwable. Clasa Exception nu își declară metodele, moștenește metodele clasei Throwable.
Constructorii și metodele utilizate de clasa Exception sunt prezentate mai jos.
Constructori
Constructor Descriere Excepție publică () Un constructor implicit care construiește o nouă excepție cu mesajul ca nul. Excepție publică (mesaj String) Constructor pentru a construi o nouă excepție cu mesajul dat. În acest caz, cauza nu este inițializată și un apel ulterior către Throwable.initCause (java.lang.Throwable) poate fi utilizat pentru a inițializa cauza. Excepție publică (mesaj șir, cauză aruncabilă) Construiește o nouă excepție utilizând un anumit mesaj și o cauză. Excepție publică (cauză aruncabilă) Construiește o nouă excepție cu cauza dată și un mesaj dat de (cause == null? Null: cause.toString ()) (care conține de obicei clasa și mesajul de detaliu al cauzei). Excepție protejată (mesaj șir, cauză aruncabilă, boolean enableSuppression, boolean writableStackTrace) Construiește o nouă excepție cu mesajul dat, cauza, suprimarea (activată sau dezactivată) și urmărirea stivei care poate fi scrisă (activată sau dezactivată).
Metode
| Metoda prototip | Descriere |
|---|---|
| public String getMessage () | Obțineți un mesaj detaliat despre excepția care a avut loc. |
| public Throwable getCause () | Obțineți cauza excepției reprezentată de un obiect aruncabil |
| public String toString () | Concatenează numele clasei cu rezultatul getMessage () și returnează șirul rezultat. |
| public void printStackTrace () | Tipărește rezultatul toString () și conținutul urmăririi stivei în fluxul de ieșire de eroare, System.err. |
| public StackTraceElement () getStackTrace () | Obțineți fiecare element din urmele stivei sub forma unui tablou. |
| public Thrillable fillInStackTrace () | Umpleți urmele stivei cu urmele curente ale stivei. |
Exemplu de excepție
În continuare, vă prezentăm un program Java pentru a demonstra un exemplu de excepție de bază. Aici oferim o variabilă de șir inițializată la o valoare nulă. Când încercăm să imprimăm această variabilă, se lansează o excepție, deoarece valoarea String nu poate fi nulă.
class Main { public static void main(String args()){ //declare a String variable and initialize it to null String myStr = null; //print the string System.out.println(myStr.length()); } } Ieșire
Tipuri de excepții în Java
Java acceptă trei tipuri de excepții:
- Excepție bifată
- Excepție nebifată
- Eroare
În această secțiune, vom discuta toate cele trei tipuri de mai sus.
# 1) Excepție bifată
Unele excepții sunt verificate în momentul compilării când este compilat codul. Acestea sunt „Excepții verificate”. Programul Java aruncă o eroare de compilare atunci când constată că codul din interiorul unui program este predispus la erori.
Ne putem ocupa de erorile de compilare aruncate prin excepția verificată, gestionând excepțiile fie prin încadrarea codului într-un bloc try-catch, fie prin utilizarea cuvântului cheie throws.
În ierarhia Excepții, clasa care moștenește direct clasa Throwable, cum ar fi IOException, ClassNotFoundException, etc. sunt toate verificate excepție, cu excepția claselor RuntimeException și Error. Acestea sunt excepții nebifate.
Următorul program Java demonstrează Excepțiile verificate, FileNotFoundException și IOException. În acest program, încercăm să deschidem un fișier inexistent și să citim din acesta.
Deoarece fișierul nu există, metoda fișierului deschis aruncă FileNotFoundException. Apoi, când încercăm să citim conținutul fișierului și să închidem fișierul, metodele de apelare aruncă IOException.
import java.io.*; class Main { public static void main(String args()) { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }Ieșire
În ieșirea de mai sus, deoarece gestionarul de excepții este absent, obținem erori de compilare pentru excepțiile verificate.
Acum, permiteți-ne să oferim o clauză pentru acest program. Deoarece părintele FileNotFoundException este IOException, vom specifica doar IOException după clauza throws.
import java.io.*; class Main { public static void main(String args()) throws IOException { FileInputStream fis = null; //Open a file fis = new FileInputStream('C:/myfile.txt'); int k; //read contents of the file while(( k = fis.read() ) != -1) { System.out.print((char)k); } //close the file fis.close(); } }Ieșire
cum să setați fișierele jar să se deschidă cu java
După cum se vede din rezultat, atunci când gestionăm excepția, acesta oferă o ieșire mai semnificativă în locul erorilor de compilare.
# 2) Excepție nebifată
Excepțiile nebifate sunt excepțiile care sunt verificate în timpul rulării. Prin urmare, în ciuda excepțiilor, o compilare de programe va avea succes. Majoritatea excepțiilor nebifate sunt aruncate din cauza datelor necorespunzătoare utilizate în program.
Clasele care moștenesc „RuntimeException” sunt excepții nebifate. Excepții precum ArrayIndexOutofBounds Exception, ArithmeticException, NullPOinterException etc. sunt exemple de excepții necontrolate.
Următorul program demonstrează o excepție necontrolată în timpul rulării care este cauzată de împărțirea unui număr la zero.
class Main { public static void main(String args()) { int num1=10; int num2=0; //divide both numbers and print the result int result=num1/num2; System.out.println(result); } }Ieșire
Vedem că programul este compilat cu succes și apoi ArithmeticException este aruncat în timpul rulării.
Exemple de excepții necontrolate:
- Indicele matricei este în afara limitelor
- NullPointerException
- IllegalArgumentException
- NumberFormatException
În afară de cele două excepții de mai sus, mai sunt câteva excepții verificate, inclusiv:
- SQLException
- InvocationTargetExecption
# 3) Greșeală
Eroarea este de obicei o situație ireversibilă și irecuperabilă într-un program și atunci când apare o eroare, programele se blochează. Unele dintre exemplele de erori dintr-un program sunt OutOfMemoryError, AssertionError și VirtualMachineError etc.
Clasa de eroare moștenește din clasa Throwable. Eroarea descrie o situație care nu poate fi gestionată și duce la blocarea unui program.
Să discutăm eroarea OutOfMemory din această secțiune ca exemplu de eroare.
Știm că toate obiectele din Java sunt alocate folosind noul operator și sunt stocate în heap. Când heap-ul se stinge din memorie, mașina virtuală Java (JVM) nu poate aloca obiectul. În același timp, colectorul de gunoi nu poate elibera nicio memorie. Această situație dă naștere la eroarea OutOfMemory.
OutOfMemoryError în Java va arăta așa cum se arată mai jos:
'exception in thread 'main' java.lang.outofmemoryerror: java heap space' Prezența OutOfMemoryError într-un program înseamnă fie că sunt procesate prea multe date, fie că obiectele sunt ținute prea mult timp. Uneori, poate fi, de asemenea, o bibliotecă terță parte care consumă memorie.
Cauzele OutOfMemoryError
# 1) Spațiu Java Heap
Dacă o aplicație are prea multe finalizatoare, atunci obiectele clasei care au metoda Finalize nu sunt recuperate imediat de colectorul de gunoi, ci sunt puse la coadă pentru finalizare ulterior. Uneori, finalizarea nu poate ține pasul cu timpul, iar memoria heap este umplută, rezultând OutOfMemoryError.
Un alt motiv pentru OutOfMemoryError este că dimensiunea heap-ului specificată poate fi insuficientă pentru aplicație.
Următorul cod demonstrează OutOfMemoryError care poate apărea din cauza unei dimensiuni imense a datelor declarată pentru o matrice.
import java.util.*; public class Main { static List list = new ArrayList(); public static void main(String args()) throws Exception { Integer() array = new Integer(100000 * 100000); } } Ieșire
# 2) Spațiul Permgen
Zona de generație permanentă din memorie poate fi, de asemenea, epuizată și ar putea genera o eroare OutOfMemory.
Dimensiunea regiunii PermGen este setată în timpul lansării JVM. Dacă utilizatorul nu setează dimensiunea, atunci se utilizează dimensiunea implicită specifică platformei.
Deși cele două de mai sus sunt de obicei principalele cauze ale apariției OutOfMemoryError, pot exista și alte cauze precum dimensiunea matricei care depășește limita VM etc.
Lista de excepții în Java
Dat mai jos este o listă cu excepțiile majore care apar în Java. Am oferit exemple de programare pentru unele dintre aceste excepții. Rețineți că acestea sunt excepții încorporate acceptate de Java.
# 1) Excepție aritmetică: Anomaliile aritmetice cum ar fi divizarea la zero rezultă în ArithmeticException.
Programul de mai jos demonstrează apariția ArithmeticException.
class Main { public static void main(String args()) { try { //define two numbers int num1 = 100, num2 = 0; int result = num1 / num2; // divide by zero //print the result System.out.println('Result = ' + result); } catch (ArithmeticException e) { System.out.println('ArithmeticException:Division by Zero'); } } }Ieșire
# 2) ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException este aruncat atunci când un element de matrice este accesat folosind un index ilegal. Indicele utilizat este fie peste dimensiunea matricei, fie este negativ.
# 3) ClassNotFoundException: Dacă nu se găsește definiția clasei, atunci se ridică ClassNotFoundException.
# 4) FileNotFoundException: FileNotFoundException este dată când fișierul nu există sau nu se deschide.
# 5) IOException: IOException este aruncat atunci când operațiunea de intrare-ieșire eșuează sau este întreruptă.
# 6) Excepție întreruptă: Ori de câte ori un fir procesează, doarme sau așteaptă, atunci acesta este întrerupt prin aruncarea InterruptedException.
# 7) NoSuchFieldException: Dacă o clasă nu conține un câmp sau o variabilă specificată, atunci aruncă NoSuchFieldException.
# 8) NoSuchMethodException: Când metoda accesată nu este găsită, atunci se ridică NoSuchMethodException.
# 9) NullPointerException: NullPointerException se ridică atunci când este trimis un obiect nul. Aceasta este cea mai importantă și cea mai comună excepție din Java.
# 10) NumberFormatException: Această excepție este ridicată atunci când o metodă nu a putut converti un șir într-un format numeric.
# 11) RuntimeException: Orice excepție care apare la runtime este o RuntimeException.
# 12) StringIndexOutOfBoundsException: Excepția StringIndexOutOfBoundsException este aruncată de clasa String și indică faptul că indexul depășește dimensiunea obiectului String sau este negativ.
# 13) EOFException: EOFException face parte din pachetul java.io și este aruncat când se ajunge la sfârșitul fișierului și se citește fișierul.
# 14) IllegalArgumentException: IllegalArgumentException este aruncat atunci când argumentele ilegale sau nevalide sunt transmise metodei. De exemplu, formatul de date greșit, valoare nulă atunci când este necesar non-nul sau argumente în afara intervalului.
Programul Java de mai jos demonstrează excepția IllegalArgumentException.
public class Main { int m; public static void setMarks(int marks) public static void main(String() args) { setMarks(45); setMarks(101); } }Ieșire
În programul de mai sus, IllegalArgumentException este aruncat în al doilea apel pentru a seta funcția Markuri unde introducem mărcile care sunt în afara intervalului (> 45).
# 15) InputMismatchException: InputMismatchException este aruncat atunci când citirea de intrare nu se potrivește cu un model specificat. De exemplu, dacă programul așteaptă un număr întreg și citește un float, atunci se ridică InputMismatchException.
# 16) NoSuchElementException: NoSuchElementException este aruncat atunci când următorul element accesat nu există.
De exemplu, în Enumerare, metoda nextElement () este utilizată pentru a accesa următorul element din enumerare. Dacă elementul nu există, atunci se aruncă NoSuchElementException. Majoritatea colecțiilor Java aruncă această excepție.
Programul prezentat mai jos demonstrează acest lucru.
import java.util.*; public class Main { public static void main(String() args) { Set hash_Set = new HashSet(); //create an empty hashSet. //This throws NoSuchElementException since hashSet is empty hash_Set.iterator().next(); } } Ieșire
adăugați șir la java matrice de șiruri
# 17) ConcurrentModificationException: ConcurrentModificationException este de obicei aruncat de clasele de colecție. Această excepție este aruncată atunci când obiectele încearcă să modifice simultan o resursă.
De exemplu, un fir nu poate modifica o colecție atunci când un alt fir îl accesează. Dacă permitem două fire, atunci cele două vor accesa simultan colecția și vor exista neconcordanțe.
Următorul exemplu demonstrează ConcurrentModificationException.
import java.awt.List; import java.util.*; public class Main { public static void main(String() args) { ArrayList A_list = new ArrayList<>(); //add elements to the ArrayList A_list.add(10); A_list.add(20); A_list.add(30); Iterator it = A_list.iterator(); while (it.hasNext()) { Integer value = it.next(); System.out.println('ArrayList Value:' + value); if (value.equals(30)) A_list.remove(value); } } } Ieșire
În programul de mai sus, în timp ce ArrayList este tipărit, încercăm să ștergem un element în același timp. Acesta este accesul simultan și, prin urmare, se aruncă o excepție.
Excepții personalizate în Java
Până acum am discutat despre toate excepțiile care sunt încorporate sau furnizate de limbajul Java. În afară de aceste excepții, ne putem defini și propriile excepții. Acestea se numesc excepții personalizate sau excepții definite de utilizator.
Folosind excepții personalizate, ne putem defini excepțiile în funcție de nevoile noastre.
Următorul exemplu arată excepția personalizată pe care am definit-o pentru o valoare Integer.
//custom exception definition class InvalidValueException extends Exception{ InvalidValueException(String s){ super(s); } } class Main{ static void validate(int int_val)throws InvalidValueException{ if(int_val<10) //value is valid if> 10 else throw exception throw new InvalidValueException('Invalid value'); else System.out.println('This is valid integer'); } public static void main(String args()){ try{ validate(9); }catch(Exception m){System.out.println('Exception occured: '+m);} System.out.println('Code after Exception'); } } Ieșire
întrebări frecvente
Q # 1) Ce vrei să spui prin excepție?
Răspuns: Un eveniment care are loc în timpul execuției unui program și perturbă fluxul normal de execuție al programului se numește Excepție. Excepția este nedorită și neașteptată și poate apărea din cauza factorilor externi sau a erorilor de programare.
Q # 2) Care este diferența dintre Eroare și Excepție?
Răspuns: Excepțiile sunt evenimentele care perturbă fluxul normal al programului. Putem gestiona excepțiile din programul nostru și putem continua cu programul în mod normal. O eroare este un eveniment irecuperabil care nu poate fi gestionat și care termină programul.
Î. 3) Ce vrei să spui prin gestionarea excepțiilor?
Răspuns: Procesul de specificare a secvenței de pași într-un program pentru gestionarea excepției se numește Exception Handling. Oferind gestionari de excepții într-un program, putem asigura fluxul normal al programului.
Q # 4) Care sunt avantajele Exception Handling în Java?
Răspuns: Folosind gestionarea excepțiilor putem menține fluxul normal de execuție al unei aplicații. De asemenea, putem răspândi erorile în stiva de apeluri atunci când oferim gestionare de excepții.
Q # 5) La ce folosește Exception Handling?
Răspuns: Nu încetați fluxul normal de execuție al unei aplicații este utilizarea principală a faptului că aveți gestionari de excepții într-un program. Fără handlerele de excepție, programul se va termina și fluxul normal de execuție va fi întrerupt atunci când apare o excepție.
Cu excepția tratată corespunzător în program, poate continua cu execuția sa normală chiar și atunci când apare o excepție.
Mai multe exemple despre excepții
O excepție este un eveniment care are loc în timp ce programul rulează și perturbă execuția programului. Din acest motiv, produsul software se va termina brusc.
Când apare această excepție, Java creează un obiect cu un mesaj de eroare și informații despre clasă. Acesta este obiectul de excepție.
De ce avem nevoie de o excepție în Java?
Clasa ExcepDemo fără excepție:
public class ExcepDemo { public static void main(String() args) { int i=5; int j=0; System.out.println(i/j); System.out.println('statement after division'); } } 
IEȘIRE:
Clasa ExcepDemo cu manipulare de excepții:
public class ExcepDemo { public static void main(String() args) { // TODO Auto-generated method stub int i=5; int j=0; try { System.out.println(i/j); } catch(ArithmeticException ae) { System.out.println('wrong input'); } System.out.println('statement after division'); } } 
IEȘIRE:
Încercați, prindeți și blocați în cele din urmă:
- O excepție este gestionată de try, catch block.
- Declarațiile care pot duce la excepții sunt scrise în blocul try.
- Când apare o excepție, instrucțiunile din blocul de captură vor fi executate. Dacă nu apare o excepție, blocul de captură nu va fi executat.
- Indiferent de excepție sau nu a avut loc, blocul final va fi executat.
Tipuri de excepții
Excepție nebifată:
Deoarece excepțiile necontrolate pot fi evitate prin programarea adecvată ( De exemplu. null pointer Exception, Arithmetic Exception) nu va fi verificat de compilator. Excepția fără bifare va fi aruncată în timpul rulării.
cum să faci un e-mail fals
Excepție bifată:
- Excepția bifată va fi verificată de compilator și este obligatorie să arunce sau să gestioneze excepția.
- Această excepție este utilizată pentru a separa codul de tratare a erorilor de codul obișnuit.
- Toate excepțiile verificate sunt grupate și este util în diferențierea problemelor.
Exemplu: java.io
import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; public class DemoExpChecked { public static void main(String() args) { try { File file=new File('input.txt'); BufferedReader br = new BufferedReader(new FileReader(file)) ; String content; while ((content=br.readLine())!=null) { System.out.println(content); } br.close(); } catch(IOException e) { e.printStackTrace(); } } } 
Erori
O eroare poate apărea din cauza greșelilor logice ale programului sau a oricărei memorii legate de problema JVM.
Exemplu: Memorie fără eroare legată sau eroare de depășire a stivei.
Aruncă și aruncă
Cuvântul cheie „Aruncă” este folosit pentru a arunca excepția, în timp ce cuvântul cheie „Aruncă” este folosit pentru a declara excepția.
Exemplu de program de aruncare:
public class Demothrow { String content ; public void driving(String c) { this.content=c; if (content.isEmpty()) { throw new NullPointerException('content is empty'); } else { System.out.println('content=='+content); } } public static void main(String() args) { Demothrow dt=new Demothrow(); dt.driving(''); } } 
Aruncă exemplu de program:
Aruncările sunt folosite pentru a oferi informații că această metodă aruncă această excepție specială. Când apelați acea metodă specială, trebuie să gestionați acea excepție.
public class DemoThrows { int i=2,j=0; public void checkmethod () throws ArithmeticException{ System.out.println(i/j); } public static void main(String() args) { DemoThrows d =new DemoThrows(); try { d.checkmethod(); } catch (ArithmeticException ae) { ae.printStackTrace(); } } } 
Puncte cheie care trebuie remarcate:
- Excepțiile sunt evenimente anormale care au avut loc în timpul execuției programului și vor afecta fluxul de execuție.
- O eroare este diferită de excepții. Exemple de erori: Memorie din eroare.
- Excepțiile verificate sunt verificate în timpul compilării și este obligatoriu să tratați această excepție verificată.
- O excepție necontrolată are loc în timpul rulării.
Concluzie
Acest tutorial despre gestionarea excepțiilor în Java a introdus definiția excepțiilor, gestionarea excepțiilor și ierarhia excepțiilor în Java. De asemenea, am discutat despre clasa de excepții în Java, care oferă diverși constructori și metode pentru accesarea excepțiilor.
Am explorat o listă cu excepțiile comune care apar în Java și am văzut exemplele de programare pentru excepția majoră. De asemenea, am discutat despre erorile majore care apar într-un program Java împreună cu tipurile de excepții și excepțiile personalizate.
=> Verificați TOATE Tutorialele Java aici.
Lectură recomandată
- Top 10 excepții de seleniu și cum să le tratezi (cod exact)
- JDBC Exception Handling - Cum să gestionați excepțiile SQL
- Cum să gestionați excepția în scripturile SoapUI Groovy - Tutorialul SoapUI # 11
- Java String cu buffer de șiruri și tutorial de generare de șiruri
- Implementarea Java: crearea și executarea fișierului Java JAR
- Fire Java cu metode și ciclu de viață
- Mașină virtuală Java: Cum ajută JVM la rularea aplicației Java
- Modificatori de acces în Java - Tutorial cu exemple