Documente Academic
Documente Profesional
Documente Cultură
Curs Java
Curs Java
65 mil. locuitori)
1
robusteţe, elimină sursele frecvente de erori ce apar în programare prin
eliminarea pointerilor, administrarea automată a memoriei şi eliminarea
fisurilor de memorie printr-o procedură de colectare a 'gunoiului' care
rulează în fundal. Un program Java care a trecut de compilare are
proprietatea că la execuţia sa nu "crapă sistemul".
complet orientat pe obiecte - elimină complet stilul de programare
procedural; se bazează pe încapsulare, moştenire, polimorfism
uşurinţă în ceea ce priveşte programarea în reţea
securitate, este cel mai sigur limbaj de programare disponibil în acest
moment, asigurând mecanisme stricte de securitate a programelor
concretizate prin: verificarea dinamică a codului pentru detectarea
secvenţelor periculoase, impunerea unor reguli stricte pentru rularea
programelor lansate pe calculatoare aflate la distanta, etc
este neutru din punct de vedere arhitectural
portabilitate, cu alte cuvinte Java este un limbaj independent de
platforma de lucru, aceeaşi aplicaţie rulând, fără nici o modificare, pe
sisteme diferite cum ar fi Windows, UNIX sau Macintosh, lucru care aduce
economii substanţiale firmelor care dezvoltă aplicaţii pentru Internet.
Sloganul de bază este: „Write once, run anywhere”
compilat şi interpretat
asigură o performanţă ridicată a codului de octeţi
conţine o librărie de clase şi interfeţe pentru domenii specifice cum ar fi
programarea interfeţelor utilizator (JFC, AWT, Swing), programare
distribuită (comunicare TCP/IP, CORBA, RMI etc.)
permite programarea cu fire de execuţie (multithreaded)
dinamicitate
este modelat după C şi C++, trecerea de la C / C++ la Java făcându-se
foarte uşor.
face diferenţa între literele mici şi mari (este case sensitive)
permite dezvoltarea aplicaţiilor pentru Internet – crearea unor
documente Web îmbunătăţite cu animaţie şi multimedia.
Java Development Kit (JDK) este disponibil gratis
2
1.3. Java : un limbaj compilat şi interpretat
1993: devine disponibil primul browser WWW (World Wide Web) Mosaic;
dezvoltarea unui web-browser (Webrunner), capabil să încarce şi să execute
programe mici scrise în Oak;
3
ianuarie 1996 : apare JDK 1.0 (soft gratuit);
februarie
În acest curs se utilizează distribuţia JDK 1.3 (Java Development Kit), produsă
de firma Sun.
Există două posibilităţi de a lucra în Java: în linie de comandă – paşii fiind
indicaţi mai jos, sau folosind un editor Java cum ar fi JCreator, Eclipse, etc.
Realizarea unui program Java constă în următorii paşi:
Editarea programului într-un editor de texte;
Salvarea programului sub numele NumeClasa.java unde NumeClasa este
numele clasei care conţine metoda main(). Într-un program Java trebuie să
existe o singură clasă care să conţină o metodă main(). Cu alte cuvinte, numele
clasei trebuie să coincidă cu numele fişierului. Extensia fişierului este .java
Compilarea programului se face cu ajutorul comenzii
javac NumeClasa.java
4
class Salut {
public static void main(String args[]) {
System.out.println("Salut !!!");
}
}
Toate aplicaţiile Java conţin o clasă principală în care trebuie să se găsească
metoda main(). Clasele aplicaţiei se pot găsi fie într-un singur fişier, fie în mai
multe.
3. Compilarea aplicaţiei
Se foloseşte compilatorul Java, javac. Apelul compilatorului se face pentru
fişierul ce conţine clasa principală a aplicaţiei. Compilatorul creează câte un fişier
separat pentru fiecare clasă a programului; acestea au extensia .class şi sunt
plasate în acelaşi director cu fişierele sursă. Rezultatul comenzii
javac Salut.java
este fişierul Salut.class
4. Rularea aplicaţiei
Se face cu interpretorul java, apelat pentru unitatea de compilare
corespunzătoare clasei principale, fiind însă omisă extensia .class asociată
acesteia.
java Salut
Rularea unei aplicaţii care nu foloseşte interfaţă grafică, se va face într-o fereastră
sistem.
5
import javax.swing.*;
import java.awt.*;
3. Compilarea applet-ului
javac Salut.java
În urma compilării rezultă fişierul Salut.class
4. Rularea applet-ului
Applet-urile nu rulează independent. Ele pot fi rulate doar prin intermediul unui
browser: Internet Explorer, Netscape sau printr-un program special cum ar fi
appletviewer-ul din setul JDK.
Crearea unui fişier HTML pentru miniaplicaţie (exemplu.html)
<html>
<head>
<title>Primul Applet Java</title>
</head>
<body>
<applet code=Salut.class width=400 height=400>
</applet>
</body>
</html>
5. Vizualizarea applet-tlui
appletviewer exemplu.html
6
2. Programarea Orientată pe Obiecte şi Java
Programarea Orientată pe Obiecte (OOP) este una dintre cele mai mari idei de
programare apărută în anii 1990. Ideea centrală a OOP este: organizarea
programelor astfel încât ele să reprezinte un ecou al modului în care lucrurile sunt
puse împreună în lumea reală.
Exemplu:
Pentru cine nu s-a jucat niciodată cu Lego, acesta constă în diferite bucăţi de
plastic, de diferite culori şi dimensiuni. Ele sunt dotate cu crescături şi adâncituri prin
intermediul cărora piesele pot fi conectate între ele. Cu diferite componente Lego se
poate forma aproape orice: maşini, oameni, castele, case, etc. în funcţie de
imaginaţia fiecăruia. Fiecare piesă de Lego este un mic obiect care împreună cu
altele ajută la crearea altor obiecte mai mari. Exact aşa stau lucrurile şi în
programarea orientată pe obiecte: obiecte mici puse împreună formează obiecte
mari.
Programarea orientată pe obiecte este gândită după modelul lumii reale –
obiectele sunt adesea formate din mai multe tipuri de obiecte mici.
Când scriem programe într-un limbaj orientat pe obiecte, nu definim obiecte ci
clase de obiecte, unde o clasă reprezintă un şablon pentru mai multe obiecte cu
caracteristici similare. Clasele întrupează toate caracteristicile unei mulţimi
particulare de obiecte. De exemplu, ne putem gândi la clasa Copac care descrie
caracteristicile tuturor copacilor (au rădăcini, trunchi şi frunze, cresc, produc clorofilă,
îşi schimbă frunzele, etc). Clasa Copac reprezintă un model abstract pentru
conceptul de copac – pentru a planta un copac, a-l atinge, a-i rupe o frunză sau a-l
tăia avem nevoie de un copac concret, altfel spus de o instanţă a copacului.
Bineînţeles că, odată ce avem clasa copac, putem crea oricâte instanţe diferite ale
7
copacului respectiv – ”copaci concreţi”. Aceştia pot avea caracteristici diferite (unii
sunt înalţi, alţii pitici, unii îşi pierd frunzele toamna, alţii nu, etc)
O altă noţiune specifică OOP este cea de obiect. Obiect sau instanţă a clasei
reprezintă acelaşi lucru. Clasa este reprezentarea generală a unui obiect iar
instanţa /obiectul este reprezentarea concretă a clasei.
2.2.1. Atribute
Atributele diferenţiază obiectele între ele şi determină aparenţa, starea sau alte
calităţi ale obiectului în cauză. Dacă ne gândim să creăm o clasă Maşină, ea ar
trebui să includă următoarele atribute: culoare, stil, marcă.
Atributele sunt definite în clase ca variabile. Tipul şi numele variabilelor
sunt definite în clase şi fiecare obiect are valori proprii pentru fiecare atribut.
8
Deoarece fiecare instanţă a clasei poate avea valori diferite pentru variabilele sale,
aceste variabile se mai numesc şi variabile instanţă.
Exemplu: O instanţă a clasei maşină, MaşinaMea ar putea avea următoarele
valori pentru atribute:
culoare = alb
stil = elegant
marcă = Mercedes
Există, de asemenea, şi un alt tip de variabile numite variabile clasă.
Diferenţa dintre cele două tipuri de variabile este aceea că valorile variabilelor
instanţă sunt păstrate în instanţe şi se schimbă pentru fiecare instanţă iar valorile
variabilelor clasă sunt păstrate în clasă şi nu se schimbă pentru fiecare instanţă.
Asupra diferenţei dintre cele două tipuri de variabile o să revin într-un capitol
următor.
2.2.2. Comportament
9
2.3. Principiile OOP
Obiectul este o variabilă care are o structura şi o stare. Fiecare obiect dispune
de operaţii prin intermediul cărora i se poate manipula starea.
Obiectul trebuie privit ca o unitate atomică pe care utilizatorul nu ar trebui să o
disece. De exemplu, când lucrăm cu numere întregi, nu ne punem problema
reprezentării lor. Utilizatorul nu are acces direct la părţile constituente ale unui obiect
sau la implementarea sa; acestea vor putea fi accesate doar prin intermediul
metodelor care au fost furnizate împreună cu obiectul. Gruparea datelor şi a
operaţiilor care pot fi efectuate asupra acestor date, având grijă ca detaliile de
implementare să fie ascunse, poarta numele de încapsulare.
Unul din principalele scopuri ale OOP este refolosirea codului. Limbajele de
programare orientate pe obiecte furnizează mai multe mecanisme în acest scop.
1. Folosirea codului generic – dacă implementarea este identică, şi diferă
doar tipul de bază al obiectului, nu este necesară rescrierea completă a
codului – se scrie un cod generic care funcţionează pentru orice tip. De
exemplu, se poate scrie o metodă care să ordoneze un şir de numere întregi,
caractere, şiruri de caractere.
2. Moştenirea este un mecanism care permite extinderea funcţionalităţii unei
clase. Se pot crea noi tipuri de date care să extindă (sau să restricţioneze)
proprietăţile tipului de date original.
3. Polimorfismul Un tip referinţă polimorfic poate să refere obiecte de mai
multe tipuri. Atunci când se apelează o metodă a tipului polimorfic, se va
selecta automat metoda care corespunde tipului referit în acel moment.
10
3. Elementele de bază ale limbajului de
programare Java
3.1.3. Identificatori
11
3.1.4. Constante
3. constante logice
true : valoarea booleană de adevăr
false : valoarea booleană de fals
Observaţie: spre deosebire de C++, constantele întregi 1 şi 0 nu mai au rolul
de adevărat şi fals.
4. constante caracter
O constantă de tip caracter este utilizată pentru a exprima caracterele
codului Unicode. Reprezentarea se face fie folosind o literă, fie o secvenţă
escape scrisă între apostrofuri. Secvenţele escape permit reprezentarea
caracterelor care nu au reprezentare grafică şi reprezentarea unor caractere
speciale precum backslash, apostrof, etc. Secvenţe escape predefinite în Java:
12
5. constante şiruri de caractere
Un şir de caractere este format din zero sau mai multe caractere cuprinse
între ghilimele. Caracterele care formează şirul de caractere pot fi caractere
grafice sau secvenţe escape. Dacă şirul este prea lung el poate fi scris ca o
concatenare de subşiruri de dimensiune mai mică. Concatenarea şirurilor se face
cu operatorul + ("Ana " + " are " + " mere "). Şirul vid este "". După
cum vom vedea, orice şir este de fapt, o instanţă a clasei String, definită în
pachetul java.lang.
3.1.5. Separatori
3.1.6. Operatori
13
a) -x reprezintă opusul lui x
b) int x=5,y=7;
x++; // x primeste valoarea 6
y--; // y primeste valoarea 6
c) int x=5,y=7;
++x; // x primeste valoarea 6
--y; // y primeste valoarea 6
d) int x=5,y;
y=x++; // y primeste valoarea 5, x primeste
valoarea 6
e) int x=5,y;
y=x--; // y primeste valoarea 5, x primeste
valoarea 4
f) int x=5,y;
y=++x; // x primeste valoarea 6, y primeste
valoarea 6
g) int x=5,y;
y=--x; // x primeste valoarea 4, y primeste
valoarea 4
14
8. operatorul condiţional: ”? : ” . Are forma:
expresie_logica ? expresie1 : expresie2
15
Rezultatul afişat este:
2 3 5
3 2 5
4 3 6
2 6 6
1 5 7
2 2 2
16
3.1.7. Comentarii
17
Long 8 -263 .. 263-1
2. tipuri reale
Tip de date Dimensiune în octeţi Domeniu
float 4 -1046 .. 1038
double 8 -10324 .. 10308
3.3. Variabile
Variabilele pot avea ca tip fie un tip primitiv de dată, fie o referinţă la un obiect.
Declararea variabilelor se face prin:
tip_de_date nume_variabila
18
Exemple:
int a; a=5;
final double PI = 3.14;
int valoare = 100;
long numarElemente = 12345678L;
String floare = "frezie";
{
...
declararea variabilelor membru
public void Metoda (parametrii metodei)
{
…
…
}
…
}
19
Observaţie: Variabilele declarate într-un for, rămân locale corpului ciclului. De
exemplu:
for(int i=0; i<100; i++) { }
int i; //posibil în Java, eroare în C++
3.4. Instrucţiuni
20
10. }
21
Dacă instrucţiunea break lipseşte atunci se execută şi instrucţiunile de pe
următoarele ramuri până la întâlnirea primului break.
Exemplu 6: Să se spună dacă un număr dat mai mic decât 10 este par sau impar.
1. public class ParImpar{
38. public static void main(String args[]){
39. int x=2;
40. switch (x) {
41. case 0:
42. case 2:
43. case 4:
44. case 6:
22
45. case 8:
46. System.out.println(x+" este numar par");break;
47. default:
48. System.out.println(x+" este numar impar");
2. }
3. }
4. }
În acest caz se obţine o buclă infinită. Pentru a evita acest lucru este necesar
ca în cadrul blocului de instrucţiuni să existe o condiţie de oprire.
23
De asemenea, blocul de instrucţiuni poate să lipsească, el fiind înlocuit de
instrucţiunea vidă. Exemplul 8 de mai jos ilustrează această situaţie.
Exemplu 9:
1. public class Factorial{
2. public static void main(String args[]){
3. long f, LimSup;
4. int n=10,i;
5. LimSup=(long)Math.pow(2,63);
6. for(i=2,f=1; i<=n && f<=LimSup/i; f*=i,i++)
7. ;
8. if (i==n+1)
9. System.out.println(n+"!="+f);
10. else
11. System.out.println(n+"!=este prea mare pentru puterile mele");
12. }
24
13. }
25
cele două instrucţiuni este că, dacă la while se executau instrucţiunile doar dacă
condiţie era adevărată, în cazul lui do-while blocul de instrucţiuni se execută
cel puţin o dată după care se verifică valoarea condiţiei.
Instrucţiunea do-while se mai numeşte şi instrucţiune cu test final.
Exemplu 11: Să se calculeze cel mai mare divizor comun a două numere a şi b.
1. public class Cmmdc{
2. public static void main(String args[]){
3. long a=54,b=68,r;
4. System.out.print("Cmmdc-ul numerelor "+a+" si "+b+"
este: ");
5. do{
6. r=a%b;
7. a=b;
8. b=r;
9. }while(r>0);
10. System.out.println(a);
11. }
12. }
În linia 5 se generează aleator un număr întreg mai mic decât b. Dacă numărul
este cuprins în intervalul [a,b] se părăseşte instrucţiunea while.
Dacă instrucţiunea break este plasată în cadrul mai multor instrucţiuni
repetitive imbricate, ea are ca efect părăsirea doar a instrucţiuni care o conţine.
26
Exemplu:
1. for(...){
2. ...
3. for(...){
4. ...
5. break;
6. ...
7. }
8. ...
9. }
Exemplu 13: Următorul cod afişează toate caracterele citite cu excepţia cifrelor de la
0 la 9.
1. public class ExContinue{
2. public static void main(String args[]){
3. for(int i=0; i<=10; i++){
4. char c=' ';
5. try{
6. c=(char)System.in.read();
7. }
8. catch(Exception e){}
9. if ( ('0'<=c) && (c<='9') )
10. continue;
11. System.out.print(c+" ");
12. }
13. }
14. }
27
3.5. Tablouri (vectori)
Exemple:
int[] v;
String adrese[];
Exemple:
v = new int[10]; //se alocă spaţiu pentru 10 întregi
adrese = new String[100]; //se alocă spaţiu pentru 100 de String-uri
Exemple:
int [] v = new int[10];
După declararea unui vector, acesta poate fi iniţializat, adică elementele sale
pot primi valori. În acest caz instanţierea lipseşte, alocarea memoriei făcându-se
automat în funcţie de numărul de elemente cu care se iniţializează vectorul.
Exemple:
28
String culori[] = {"Rosu", "Galben", "Verde"};
int []v = {2, 4, 6, 8, 10, 12};
Observaţii:
Primul indice al unui vector este 0, deci poziţiile unui vector cu n elemente vor
fi cuprinse între 0 şi n-1.
Nu sunt permise construcţii de genul:
TipElement numeVector[dimensiune]
alocarea memoriei făcându-se doar prin intermediul operatorului new sau prin
iniţializare.
Exemple:
int v[10]; //incorect
int v[] = new int[10]; //corect
Exemplu 1:
int v[]=new int[10];
for(i=0; i<10; i++)
v[i]=i;
Exemplu 2:
int v[]={1,2,3,4,5};
for(i=0; i<5; i++)
System.out.println(v[i]+” “);
În Java tablourile cu mai multe dimensiuni sunt de fapt vectori de vectori. Prin
urmare, declararea, instanţierea şi iniţializarea se fac la fel ca în cazul vectorilor
unidimensionali.
TipElement numeVector[][]… = new TipElement[dim1][dim2]…
sau
TipElement[][]… numeVector = new[dim1][dim2]… TipElement
sau parantezele pot fi de o parte şi de alta a lui numeVector.
29
Exemplu:
int m[][]; //declararea unei matrice
m = new int[5][10]; //cu 5 linii, 10 coloane
Observaţie:
m[0], m[1], ..., m[4] sunt vectori de întregi cu 10 elemente
30
6. for(int j=0; j<a[i].length; j++)
7. System.out.print(a[i][j]+" ");
8. System.out.println("");
9. }
10. do{
11. ordonat=true;
12. for(int i=0; i<a.length-1; i++)
13. if (a[i][i]>a[i+1][i+1]){
14. int aux=a[i][i];
15. a[i][i]=a[i+1][i+1];
16. a[i+1][i+1]=aux;
17. ordonat=false;
18. }
19. }while(!ordonat);
20. System.out.println("Matricea cu diagonala
ordonata:");
21. for(int i=0; i<a.length; i++){
22. for(int j=0; j<a[i].length; j++)
23. System.out.print(a[i][j]+" ");
24. System.out.println("");
25. }
26. }
27. }
31
18. }
19. }
În linia 8 se observă că, pentru fiecare linie a matricei se alocă memorie pentru
un număr variabil de elemente: pe linia 0 va fi memorat un element, pe linia 1 vor fi
memorate două elemente, etc.
32
4. Clase şi obiecte în Java
4.1. Referinţe
După cum am arătat în capitolul 2, o clasă este un şablon pentru mai multe
obiecte cu caracteristici asemănătoare. Un obiect este o colecţie de variabile
(atribute) şi metode asociate descrise în clasă.
Clasa poate fi asemănată cu un tip de date iar obiectul cu o variabilă. Dacă se
declară o variabilă folosind numele unei clase ca şi tip, această variabilă conţine o
referinţă către un obiect al clasei respective. Cu alte cuvinte, variabila nu va conţine
obiectul actual ci o referinţă către un obiect / o instanţă a clasei. Deoarece folosind
numele unei clase ca şi tip se declară o referinţă către un obiect, aceste tipuri poartă
numele de tipuri referinţă.
Se disting două caracteristici principale ale obiectelor în Java:
obiectele sunt întotdeauna alocate dinamic. Durata de viaţă a unui
obiect este determinată de logica programului. Ea începe atunci când
obiectul este creat şi se termină în momentul în care obiectul nu mai
este folosit, el fiind distrus de un mecanism de curăţenie oferit de
limbajul Java – garbage collector (colectorul de gunoaie).
obiectele nu sunt conţinute de către variabile. O variabilă păstrează o
referinţă către un obiect. o referinţă este similară cu ceea ce se
numeşte pointer în alte limbaje de programare cum ar fi C++. Dacă
există două variabile de acelaşi tip referinţă şi o variabilă este atribuită
celeilalte, ambele vor referi acelaşi obiect. Dacă informaţia din obiect se
modifică, schimbarea este vizibilă în ambele variabile.
O variabilă referinţă poate conţine şi o referinţă către nimic. Valoarea unei
asemenea variabile referinţă este null.
În Java nu se permite tipurilor referinţă să fie convertite către tipuri primitive
sau invers.
În capitolul 2 am văzut cum se poate lucra cu tablouri (şiruri) fără să ne punem
problema cu ce tip de date lucrăm – primitiv sau referinţă. În Java, şirurile nu sunt
tipuri primitive ci referinţă. Ele se comportă ca nişte obiecte.
33
4.2. Obiecte
În Java obiectele sunt create prin instanţierea unei clase, cu alte cuvinte prin
crearea unei instanţe a unei clase.
Declararea obiectului se face prin:
NumeClasa numeObiect;
Exemplu:
String s;
Complex c;
34
Exemplu:
Complex c = new Complex();
c.re = 2;
c.im = 3;
System.out.println("Re=" +c.re+ " Im="+c.im);
Exemplu:
Complex c = new Complex();
c.setRe(2);
c.setIm(3);
În cazul în care operatorul = este folosit împreună cu date de tip primitiv, are
loc o atribuire de valori.
Exemplu:
int x = 12, y = 10;
x = y;
35
Exemplu:
1. class Nimic{
2. int x;
3. }
4. class Test{
5. public static void main(String args[]){
6. Nimic a1=new Nimic(),a2;
7. a1.x=10;
8. a2=a1;
9. System.out.println(a1.x+" "+a2.x);
10. a1.x=5;
11. System.out.println(a1.x+" "+a2.x);
12. }
13. }
Rezultatul este:
23456
23456
36
4.2.3. Operatorul de egalitate ==
În cazul în care operatorul == este folosit împreună cu date de tip primitiv, are
loc o testare a egalităţii valorilor celor două variabile.
Exemplu:
int x = 12, y = 10, z = 12;
x == y are valoarea false; x şi y au valori diferite
x == z are valoarea true; x şi z au valori egale
În cazul în care operatorul = este folosit împreună cu date de tip referinţă, se
verifică dacă cele două variabile referă acelaşi obiect.
Exemplu:
1. class Nimic{
2. int x;
3. Nimic(int x){
4. this.x=x;
5. }
6. }
7. class Test{
8. public static void main(String args[]){
9. Nimic a1=new Nimic(1),a2=new Nimic(1);
10. if(a1==a2)
11. System.out.println("Sunt egale");
12. else
13. System.out.println("Nu sunt egale");
14. a2=a1;
15. if(a1==a2)
16. System.out.println("Sunt egale");
17. else
18. System.out.println("Nu sunt egale");
19. }
20. }
În linia 9 se creează două obiecte cu aceeaşi valoare. Totuşi testul din linia 10
are ca rezultat valoarea false. După linia 14 cele două variabile referă acelaşi
obiect şi, prin urmare, testul din linia 15 are ca rezultat valoarea true.
37
4.3. Clase
38
Observaţie: O clasă declarată atât abstractă cât şi finală generează eroare.
Dacă clasa este abstractă înseamnă că ea conţine metode neimplementate şi, prin
urmare trebuie extinsă de o altă clasă care să le implementeze. Dar, dacă ar fi şi
finală, nu ar putea fi extinsă.
După numele clasei se pot specifica, dacă este cazul, clasele moştenite şi
interfeţele implementate. O clasă poate moşteni o singură clasă, prin urmare dacă
apare clauza extends ea este urmată doar de numele unei clase. Însă, o clasă
poate implementa mai multe interfeţe, ale căror nume apar după clauza
implements şi trebuie separate prin virgulă. Asupra moştenirii şi interfeţelor se
găsesc mai multe detalii în subcapitolele „Moştenire” respectiv „Interfeţe”.
Corpul unei clase urmează după antetul clasei şi este cuprins între acolade.
Conţine:
declararea variabilelor instanţă şi clasă care împreună formează
variabilele membru;
definirea metodelor instanţă şi clasă care împreună formează metodele
membru.
Observaţie: variabilele unei clase pot avea acelaşi nume cu metodele clasei.
39
tipul variabilei: instanţă sau clasă
Tiparul declarării unei variabile este:
[modificatori] TipDeDate numeVariabila [ = valoareInitiala ] ;
unde un modificator poate fi :
un specificator de acces: public, protected, private;
unul din cuvintele rezervate: static, final, transient, volatile.
Exemple:
double x;
protected static int n;
public String s = "abcd";
private Point p = new Point(10, 10);
final long MAX = 100000L;
Exemplu: se declară o variabilă finală (linia 2). În linia 4 se iniţializează iar în linia 5
se doreşte modificarea valorii ei.
1. class Test {
2. final int MAX;
3. Test() {
4. MAX = 100; // legal
40
5. MAX = 200; // ilegal -> eroare la compilare
6. }
7. }
4.3.3. Metode
41
abstract este folosit pentru declararea metodelor abstracte. O metodă
abstractă este o metodă care nu are implementare şi trebuie să aparţină
unei clase abstracte.
final este folosit pentru a specifica faptul că acea metodă nu mai poate fi
supradefinită în subclasele clasei în care ea este definită ca fiind finală.
Acest lucru este util dacă respectiva metodă are o implementare care nu
trebuie schimbată în subclasele ei.
native este folosit pentru refolosirea unor funcţii scrise în alt limbaj de
programare decât Java (C de exemplu).
synchronized este folosit în cazul în care se lucrează cu mai multe fire de
execuţie iar metoda respectivă se ocupă cu partajarea unei resurse
comune. Are ca efect construirea unui semafor care nu permite executarea
metodei la un moment dat decât unui singur fir de execuţie.
Dacă valoarea returnată este o referinţă la un obiect al unei clase, atunci clasa
obiectului returnat trebuie să coincidă sau să fie o subclasă a clasei specificate la
declararea metodei.
42
4.3.3.4 Parametrii unei metode
După cum am văzut, numele clasei este urmat de lista parametrilor
(argumentelor), listă care este opţională (o metodă poate să nu aibă parametrii).
Parametrii sunt specificaţi prin numele şi tipul lor, fiind despărţiţi unul de altul prin
virgulă.
NumeMetoda([tip1 argument1], [tip2
argument2] ... )
Tipul de date al unui argument poate fi orice tip valid al limbajului, atât tip
primitiv de date cât şi referinţă la un obiect.
Exemplu:
void adaugarePersoana(String nume, int varsta, float
salariu){
...
}
unde String este tip referinţă, int şi float sunt tipuri primitive.
În Java o metodă nu poate primi un număr variabil de argumente, ceea ce
înseamnă că apelul unei metode trebuie să se facă cu specificarea exactă a
numărului şi tipurilor argumentelor.
Nu este permisă gruparea parametrilor după tipul lor.
Exemplu:
public int max(int a,b){...} //este greşit
public int max(int a, int b){ ...} //este corect
43
Asta însemnă că metoda recepţionează doar valorile variabilelor primite ca
parametri. Când argumentul are tip primitiv de date metoda nu-i poate schimba
valoarea decât local (în cadrul metodei); la revenirea din metodă variabila are
aceeaşi valoare ca la apelul iniţial al metodei (modificările făcute în cadrul metodei
sunt pierdute). Când argumentul este de tip referinţă metoda nu poate schimba
referinţa obiectului însă poate schimba variabilele membru ale respectivului obiect.
Prin urmare, dacă dorim ca o metodă să schimbe starea (valoarea) unui argument
primit, atunci el trebuie să fie neapărat de tip referinţă (trebuie să fie un obiect!).
Constructorii unei clase sunt metode speciale care au acelaşi nume cu cel al
clasei, nu returnează nici o valoare şi sunt folosiţi pentru iniţializarea obiectelor
acelei clase în momentul instanţierii lor. Constructorii controlează modul în care un
obiect este creat şi iniţializat.
Class COMPLEX {
COMPLEX() {
//constructor
}
}
O clasă poate avea unul sau mai mulţi constructori care trebuie însă să difere
prin lista de parametri primiţi. Astfel sunt permise diferite tipuri de iniţializări ale
obiectului la crearea sa, în funcţie de numărul parametrilor cu care este apelat
constructorul.
Exemplu: Clasa COMPLEX are trei constructori: unul fără parametrii definit în liniile
3-5, altul cu doi parametrii definit în liniile 6-8, altul cu un parametru definit în liniile 9-
11.
1. class COMPLEX {
2. double re, im;
3. COMPLEX () {
4. re=im=0;
5. }
6. COMPLEX (double r, double i ) {
7. re=r; im=i;
8. }
9. COMPLEX (double r) {
10. re=r; im=0;
44
11. }
12. }
Exemplu: În clasa COMPLEX a fost definit constructorul cu doi parametrii. Ceilalţi doi
constructori fac apel la constructorul cu doi parametrii în liniile 4 şi 10.
1. class COMPLEX {
2. double re, im;
3. COMPLEX () {
4. this(0,0);
5. }
6. COMPLEX (double r, double i ) {
7. re=r; im=i;
8. }
9. COMPLEX (double r) {
10. this(r,0);
11. }
12. }
45
Exemplu: În clasa COMPLEX au fost definiţi doi constructori: cu un parametru şi cu
doi parametrii. În linia 11 se apelează constructorul fără parametrii. Această linie
generează o eroare deoarece nu există constructor fără parametrii – el nu a fost
creat implicit.
1. class COMPLEX {
2. double re, im;
3. COMPLEX (double r, double i ) {
4. re=r; im=i;
5. }
6. COMPLEX (double r) {
7. this(r,0);
8. }
9. }
10. ...
11. COMPLEX c= new Complex(); //eroare
46
4. this.re = re;
5. this.im = im;
6. }
7. }
47
14. ...
15. ContBancar c=new ContBancar(100);
16. c.transfer(c);
48
14. m=max(a,b,c);
15. System.out.println("Max. dintre "+a+", "+b+" si
"+c+" este: "+m);
16. }
17. }
.
supradefinirea (overriding): o subclasă a unei clase poate rescrie o metodă
a clasei părinte, prin implementarea unei metode cu acelaşi antet ca al
superclasei.
49
protected String secret;
public float[] elemente;
long x;
private void metodaInterna();
public void setRe(int re);
50
variabila nr_puncte va contoriza câte ”puncte” (instanţe ale clasei Punct) se
creează. În clasa TestPunct se creează trei obiecte de tipul Punct şi se afişează
valoarea variabilei clasă nr_puncte. Trebuie remarcat că variabila nr_puncte
este accesată prin intermediul numelui clasei.
1. class Punct{
2. int x, y;
3. static int nr_puncte=0;
9. class TestPunct{
10. public static void main(String args[]){
11. Punct p1=newPunct(10, 10);
12. Punct p2=newPunct(20, 20);
13. Punct p3=newPunct(30, 30);
14. System.out.println(Punct.nr_puncte);
15. }
16. }
Exemplu: În clasa Cerc sunt definite: o metodă instanţă în liniile 6-11 care
returnează cercul cu raza cea mai mare şi o metodă clasă în liniile 12-18 care
returnează cercul cu raza cea mai mare dintre cele două cercuri primite ca
parametru. În liniile 21, 22 sunt create două cercuri a şi b cu raze diferite. În linia 23
este apelată metoda maimare a obiectului a. În linia 24 este apelată metoda
maimare a clasei Cerc.
1. class Cerc{
51
2. double x,y,r;
6. Cerc maimare(Cerc c) {
7. if(c.r>r)
8. return c;
9. else
10. return this;
11. }
Membrii clasă (statici) sunt folosiţi pentru a pune la dispoziţie valori şi metode
independente de starea obiectelor dintr-o anumită clasă.
Spre deosebire de C++, în Java nu putem avea funcţii globale definite ca
atare, întrucât "orice este un obiect". Din acest motiv şi metodele care au o
funcţionalitate globală trebuie implementate în cadrul unei clase. Acest lucru se va
face prin intermediul metodelor clasă (globale), deoarece acestea nu depind de
starea particulară a obiectelor din clasa respectivă. De exemplu, să considerăm
funcţia globală sqrt care extrage radicalul dintr-un număr şi care se găseşte în clasa
Math. Dacă nu ar fi fost funcţie clasă, apelul ei ar fi trebuit făcut astfel:
Math m = new Math();
double rad121 = m.sqrt(121);
ceea ce ar fi fost extrem de neplăcut pentru programatori. Fiind însă funcţie
statică ea poate fi apelată prin: Math.sqrt(121).
52
4.3.9. Argumente în linia de comandă
Un apel de genul:
java ArgLinCom Nu mai vine primavara odata
va produce următorul rezultat:
Nu
mai
vine
primavara
odata
53
Dacă o anumită parte din şirul de intrare este cuprinsă între ghilimelele se
interpretează ca un singur argument, spaţiile fiind ignorate.
Una apel de genul:
java ArgLinCom "Nu mai vine" primavara odata
va produce următorul rezultat:
Nu mai vine
primavara
odata
Dacă se doreşte ca din linia de comandă să fie transmise argumente
numerice, acestea sunt primite de metoda main sub forma unui vector de String-
uri. Ulterior ele trebuie convertite din String-uri în numere. Acest lucru se
realizează cu metode de tipul parseXXX aflate în clasa XXX corespunzătoare tipului
în care vrem să facem conversia: Integer, Float, Double, etc.
Exemplu:
1. public class Maxim {
2. public static int max(int a, int b){
3. return a>b?a:b;
4. }
6. int m=a>b?a:b;
7. m=m>c?m:c;
8. return m;
9. }
54
În linia 11 se verifică dacă au fost transmişi atâţia parametrii câţi sunt necesari.
În liniile 15-17 se convertesc argumentele în întregi.
4.4. Moştenirea
55
Exemplu: Următoare ierarhie de clase:
se exprimă în Java astfel: A
class A{
...
}
B
class B extends A{
...
}
class C extends B{
... C D
}
class D extends B{
...
}
A B
56
- schimbarea sau inserarea unei clase în partea de sus a ierarhiei
determină automat schimbări în comportamentul claselor de jos
Ce se întâmplă când o clasă conţine o metodă care are acelaşi antet cu
metoda unei superclase? Este executată prima metodă întâlnită – căutarea făcându-
se pornind de la baza ierarhiei în sus. Datorită acestui fapt, se pot scrie metode care
să ascundă metodele din superclase.
Dacă o metodă din superclasă nu este rescrisă ea va fi luată ca atare de
subclasă. Nu acelaşi lucru se întâmplă şi cu constructorii. Fiecare clasă derivată
trebuie să îşi definească proprii constructori. Dacă nu se scrie nici un constructor în
subclasă, atunci se generează constructorul implicit.
14. ...
57
2. public RationalIred(){
3. m=0; n=1;
4. }
58
18. public RationalIred(long m,long n){
19. super(m,n);
20. }
21. public RationalIred produs(RationalIred r){
22. super.produs(r);
23. System.out.println("si ireductibile");
24. }
25. }
Observaţii:
Când se doreşte apelarea constructorului superclasei se foloseşte doar
super(...).
Când se doreşte apelarea unei metode a superclasei se foloseşte
super.NumeMetoda(...).
4.4.2. Interfeţe
59
Exemplu:
1. interface NumeInterfata {
2. int x = 100; //corect
3. public static final int y = 100; //corect
4. private z=100; //incorect
5. int a; //incorect
6. }
Atenţie:
Variabilele şi metodele unei interfeţe sunt implicit publice chiar dacă nu sunt
declarate cu modificatorul public.
Variabilele unei interfeţe sunt implicit constante chiar dacă nu sunt declarate
cu modificatorii static şi final.
Implementarea unei interfeţe se face prin intermediul cuvântului cheie
implements:
class NumeClasa implements NumeInterfata
sau
class NumeClasa implements Interfata1, Interfata2...
O clasă poate implementa oricâte interfeţe. O clasă care implementează o
interfaţă trebuie obligatoriu să definească toate metodele interfeţei.
60
6. int r;
7. Cerc(int r){
8. this.r=r;
9. System.out.println("Constructor cerc "+r);
10. }
11. public void desen(){
12. System.out.println("Deseneaza cercul "+r);
13. }
14. public void arie(){
15. double s=Math.PI*r*r;
16. System.out.println("Cercul "+r+" are aria "+s);
17. }
18. }
61
Dreptunghiul 20 25 are aria 500.0
4.5. Probleme
62
super.opreste(); // apelul metodei clasei de baza
}
63
Dreptunghi(){}
Dreptunghi(int L,int l){
this.L=L;
this.l=l;
System.out.println("Constructor dreptunghi "+L+"
"+l);
}
void desen(){
System.out.println("Deseneaza dreptunghiul "+L+"
"+l);
}
void arie(){
double s=L*l;
System.out.println("Dreptunghiul "+L+" "+l+" are
aria "+s);
}
}
64
public class TestFigGeom{
public static void main(String args[]){
FigGeom c=new Cerc(10),
d=new Dreptunghi(20,25),
p=new Patrat(30),
pm=new Patratel(40);
c.desen();
c.arie();
d.desen();
d.arie();
// p.desen(100); da eroare p fiind o figura
geometrica
p.desen(); //se apeleaza desen din dreptunghi
p.arie();
pm.desen(); //se apeleaza desen din dreptunghi
pm.arie();
Patrat p1=new Patrat(300);
p1.desen(100); //este ok
p1.arie();
}
}
65
Exemplu 3: Ilustrează ordinea iniţializărilor
class Floare {
Floare(int nr) {
System.out.println("Floare(" + nr + ")");
}
void actiune(String fel) {
System.out.println("actiune(" + fel + ")");
}
}
class Vaza {
static Floare f1 = new Floare(1); //var STATICA
Vaza() {
System.out.println("Vaza()");
f2.actiune("Floare in vaza");
}
void pozitie(String loc) {
System.out.println("pozitie(" + loc + ")");
}
static Floare f2 = new Floare(2); //var STATICA
}
class Gradina {
Floare f3 = new Floare(3);
static Floare f4 = new Floare(4); //var STATICA
Gradina() {
System.out.println("Gradina()");
f4.actiune("Floare doarme");
}
void aspect(String tip) {
System.out.println("aspect(" + tip + ")");
}
static Floare f5 = new Floare(5); //var STATICA
}
66
Floare(1)
Floare(2)
Vaza()
actiune(Floare in vaza)
Floare(4)
Floare(5)
Floare(3)
Gradina()
actiune(Floare doarme)
Creaza o Gradina() noua in main
Floare(3)
Gradina()
actiune(Floare doarme)
Creaza o Gradina() noua in main
Floare(3)
Gradina()
actiune(Floare doarme)
pozitie(pe masa)
aspect(frumos)
public Rational(){
this(1,0);
}
67
this.m=m;
}
public RationalIred(){
super();
}
68
p.setm(getm()*r.getm());
p.setn(getn()*r.getn());
p.simplifica();
return p;
}
69
5. Pachete
70
5.1. Importul unui pachet, al unei clase sau a unei interfeţe
O dată realizat într-un fişier importul pachetului, orice clasă din pachet poate fi
accesată prin numele ei.
Exemplu: Clasa Date aparţine pachetului java.util.
import java.util.*;
public class ExData{
public static void main(String[] args) {
Date d=new Date(2003,4,13);
System.out.println(d);
}
}
Atenţie: În cazul în care sunt importate două pachete care conţin o clasă cu
acelaşi nume atunci referirea la ea trebuie făcută folosind numele complet al clasei
respective (nume pachet urmat de nume clasă).
Implicit, mediul Java importă trei pachete:
pachetul java.lang
pachetul curent
pachetul implicit (fără nume)
71
Exemplu:
import java.util.Date;
public class ExData{
public static void main(String[] args) {
Date d=new Date(2003,4,13);
System.out.println(d);
}
}
În cazul în care nu avem nevoie decât de câteva clase dintr-un pachet este
mai eficient să importăm clasele decât întregul pachet.
72
Clasele care folosesc pachetul creat se aşează în afara directorului. Pentru ca
ele să aibă acces la pachet trebuie setată variabila sistem CLASSPATH:
SET CLASSPATH = CaleDirectorNumePachet
void a(){
System.out.println(a);
}
public void b(){
System.out.println("public "+ b);
}
protected void d(){
System.out.println("protected "+d);
}
}
73
SET CLASSPATH = c:\lucru
public Vector(){
a=new double[1];
}
74
public void setElem(int poz, double val){
a[poz]=val;
}
package Tablou;
public class Matrice{
private double a[][];
public Matrice(){
a=new double[1][];
}
75
String s="";
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length; j++)
s+=a[i][j]+" ";
s+="\n";
}
return s;
}
}
76
6. Excepţii
77
excepţiei se numeşte prinderea excepţiei ("catch the exception").
Cu alte cuvinte la apariţia unei erori este "aruncată" o excepţie iar cineva trebuie să
o "prindă" pentru a o trata. Dacă sistemul nu găseşte nici un analizor pentru o
anumita excepţie atunci programul Java se opreşte cu un mesaj de eroare.
Ierarhia claselor ce conţin excepţii este:
try{
instrucţiuni ce pot declanşa excepţii
}
[catch(ClasaExceptie obiectExceptie){
instrucţiuni de tratare a excepţiei de clasă ClasaExceptie
}]*
[finally{
instrucţiuni care se execută necondiţionat în final
}]
78
înaintea părăsirii instrucţiunii try. Instrucţiunea try trebuie să aibă fie o clauză
catch, fie una finnaly.
2.
try{
...
}
catch(ClasaExceptie obiectExceptie){... }
...
catch(ClasaExceptie obiectExceptie){... }
3.
try{
...
}
finnaly{... }
4.
try{
...
}
catch(ClasaExceptie obiectExceptie){... }
...
catch(ClasaExceptie obiectExceptie){... }
finnaly{... }
În cazul în care este declanşată o excepţie şi există mai multe clauze catch,
este căutată, în ordine, acea clauză care poate trata excepţia. Adică este găsită o
clauză a cărui parametru are un tip care se potriveşte cu tipul excepţiei. Ordinea în
care clauzele catch apar este importantă: clauzele catch mai specifice trebuie să
apară înaintea celor mai generale. Dacă nu există o clauză care să trateze excepţia,
aceasta este propagată în sus, la instrucţiunile imediat următoare.
79
Excepţii uzuale:
ArithmeticException Depăşire limită tip sau împărţire la 0
NumberFormatException Conversia nepermisă a unui
String la un tip numeric
IndexOutOfBoundsException Indice ilegal într-un şir
NegativeArraySizeException Crearea unui şir cu număr negativ
de elemente
NullPointerException Tentativă de a folosi o referinţă care
are valoarea null
SecurityException Încălcarea normelor de securitate în
timpul execuţiei
Adeseori poate apărea necesitatea creării unor excepţii proprii pentru a pune
în evidenţă cazuri speciale de erori provocate de clasele unei librării, cazuri care nu
au fost prevăzute în ierarhia excepţiilor standard Java.
O excepţie proprie trebuie să se încadreze în ierarhia excepţiilor Java, cu alte
cuvinte clasa care o implementează trebuie să fie subclasă a clasei Exception.
public class ExceptieNoua extends Exception{ ... }
Exemplu:
1. public class Exc extends Exception{
2. public Exc(){
3. super(); //apeleaza constructorul clasei Exception
4. ...
5. }
6. }
Într-o clasă în care se doreşte folosirea unei excepţii există o metodă care creează
excepţia (obiect al clasei de excepţii), mai multe metode care aruncă excepţia
primită şi, eventual o metodă care o prinde, adică o tratează. Dacă într-o metodă
apare o excepţie – creată în metoda respectivă sau ca urmare a apelării unei
metode care a aruncat o excepţie, atunci ea trebuie fie să fie tratată, fie să fie
aruncată mai departe. În ambele cazuri codul care ar putea genera excepţia trebuie
pus în cadrul unei instrucţiuni try care să aibă o clauză catch cu parametru care
să coincidă cu clasa excepţiei. Dacă excepţia se doreşte să fie tratată, atunci în
80
clauza catch se pune un cod corespunzător. Dacă se doreşte ca excepţia să nu fie
tratată atunci ea trebuie aruncată mai departe (metodei care a făcut apelul) şi acest
lucru se realizează prin adăugarea clauzei throws ClasaExceptie în antetul
metodei.
9. public Rational(){
10. this(1,0);
11. }
12. public Rational(long m,long n){
13. setm(m);
14. setn(n);
15. }
16. public Rational(long m){
17. this(m,1);
18. }
19. public void setm(long m){
20. this.m=m;
21. }
22. public long getm(){
23. return m;
24. }
25. public void setn(long n){
26. this.n=n;
27. }
28. public long getn(){
29. return n;
30. }
31. public Rational produs(Rational r){
32. return new Rational(m*r.m,n*r.n);
33. }
34. public String toString(){
35. return m+"/"+n;
36. }
37. }
81
39. public RationalIred(){
40. super();
41. }
42. public RationalIred(long m,long n) throws Exc{
43. setm(m);
44. try{
45. setIn(n);
46. }
47. catch(Exc e){throw e;}
48. }
49. public void setIn(long n) throws Exc{
50. if (n!=0)
51. super.setn(n);
52. else
53. throw new Exc();
54. }
55. private void simplifica(){
56. long x=getm(), y=getn();
57. while(x!=y){
58. if(x>y) x-=y;
59. else y-=x;
60. }
61. setm(getm()/x);
62. setn(getn()/x);
63. }
64. public RationalIred produs(RationalIred r){
65. RationalIred p=new RationalIred();
66. p.setm(getm()*r.getm());
67. p.setn(getn()*r.getn());
68. p.simplifica();
69. return p;
70. }
71. }
82
90. }
91. }
83
7. Intrări şi ieşiri
84
închide flux
85
Ierarhia claselor pentru fluxuri de intrare pe caractere este:
86
Ierarhia claselor pentru fluxuri de ieşire pe octeţi:
87
Analog, clasele Writer şi OutputStream definesc metode similare pentru
afişarea datelor, tipul parametrilor variind.
Clasa Writer
int write()
int write(char cbuf[ ])
int write(char cbuf[ ], int index, int lungime)
Clasa OutputStream
int write()
int write(byte cbuf[ ])
int write(byte cbuf[ ], int index, int lungime)
Prin urmare, crearea unui flux de date care scrie / citeşte informaţii de la un
dispozitiv extern are formatul general:
FluxPrimitiv numeFlux = new FluxPrimitiv (dispozitiv extern)
88
7.5. Citirea datelor de la tastatură
89
7.5.2. Clasa InputStreamReader
90
În cazul folosirii clasei InputStreamReader, citirea se face caracter cu
caracter (adică, discul este accesat de fiecare dată). Pentru a creşte eficienţa se
foloseşte un flux care utilizează o zonă tampon pentru citire (BufferedReader).
Clasa BufferedReader are definită metoda read() cu aceeaşi signatură ca şi cea
definită în InputStreamReader dar, în plus, defineşte şi metoda readLine().
Această metodă poate fi folosită pentru a citi un şir de caractere terminat cu ’\n’,’\r’
sau ’\r\n’.
Clasa FileReader este folosită la citirea datelor dintr-un fişier text. Cei mai
importanţi constructori ai săi sunt:
creează un flux care citeşte caractere din fişierul nume
public FileReader(String nume) throws
FileNotFoundException
91
creează un flux care citeşte caractere din fişierul varFis.
public FileReader(File varFis) throws
FileNotFoundException
Clasa FileWriter este folosită la scrierea datelor într-un fişier text. Cei mai
importanţi constructori ai săi sunt:
creează un flux care scrie caractere in fişierul nume
public FileWriter (String nume) throws IOException
92
13. catch (IOException e) {
14. System.out.println("Error: " + e.toString());
15. }
16. }
17. }
8. Applet-uri
Unul dintre scopurile limbajului Java a fost crearea unor programe mici
(applet) care să ruleze în interiorul unui browser Web.
Un applet reprezintă o suprafaţă de afişare (container) ce poate fi inclusă într-o
pagina Web şi gestionată printr-un program Java. Un astfel de program se mai
numeşte miniaplicaţie.
Codul unui applet poate fi format din una sau mai multe clase. Una dintre
acestea este principală şi extinde clasa JApplet, fiind clasa ce trebuie specificată în
documentul HTML ce descrie pagina de Web în care dorim să includem applet-ul.
Diferenţa fundamentală dintre un applet şi o aplicaţie constă în faptul că, un applet
nu poate fi executat independent, ci va fi executat de browser-ul în care este
încărcată pagina Web ce conţine applet-ul respectiv. O aplicaţie independentă este
executată prin apelul interpretorului java, având ca parametru numele clasei
principale a aplicaţiei, clasa principală fiind cea care conţine metoda main.
Un applet nu se poate atinge de hardisk-ul local prin citiri sau scrieri. Scrierea
este împiedicată din cauza viruşilor care s-ar putea instala, iar citirea deoarece nu se
doreşte preluarea de informaţii de pe staţia locală.
Un neajuns al applet-urilor ar putea fi timpul destul de lung necesar încărcării
lor. O metodă de înlăturare a acestui neajuns ar fi arhivarea applet-urilor într-un fişier
JAR (Java ARchive) care să cuprindă toate componentele. Astfel, fişierul compresat
este download-at la o singură tranzacţie cu server-ul.
Un avantaj al folosirii applet-urilor este lipsa necesităţii instalării lor. De fapt,
instalarea este automată de câte ori utilizatorul încarcă pagina Web care conţine
applet-ul.
Pachetul care oferă suport pentru crearea de applet-uri este javax.swing.
Clasa JApplet furnizează tot ce este necesar pentru construirea şi întreţinerea unui
93
applet. Crearea unui applet implică implementarea metodelor puse la dispoziţie de
clasa JApplet care ne ajută să descriem comportamentul dorit al applet-ului.
Ierarhia de clase este:
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Panel
|
+--java.applet.Applet
|
+--javax.swing.JApplet
94
Oprirea definitivă – La închiderea tuturor instanţelor browser-ului folosit
pentru vizualizare, applet-ul va fi eliminat din memorie şi va fi apelată
metoda destroy a acestuia, pentru a-i permite să elibereze resursele
deţinute. Apelul metodei destroy este întotdeauna precedat de apelul lui
stop.
import javax.swing.JApplet;
import java.awt.*;
import java.awt.event.*;
95
}
8.4. HTML
Un browser Web interpretează conţinutul (textul) unui fişier .html (Hyper Text
Markup Language). Limbajul HTML constă într-o colecţie de marcaje (tag-uri).
Marcajele au rolul de a descrie modul în care va apărea afişat textul, de a comanda
browser-ului să utilizeze şi alte resurse Internet, aflate în fişiere diferite.
Sintaxa unui marcaj este:
<NumeTag [parametri ]> text </NumeTag>
96
CODE – valoarea lui este numele fişierului care conţine clasa applet-
ului: NumeClasa.class;
WIDTH – valoarea lui este lăţimea ferestrei atribuită de browser applet-
ului la afişarea documentului .html;
HEIGHT – valoarea lui este înălţimea ferestrei atribuită de browser
applet-ului la afişarea documentului .html;
Parametrii opţionali:
CODEBASE – valoarea lui este adresa URL (Universal Resource
Locator) sau calea la fişierul cu clasa applet-ului. Dacă parametru
lipseşte, căutarea clasei se face în directorul curent (cel din care a fost
încărcat fişierul .html);
VSPACE – valoarea lui este înălţimea zonei (exprimată în pixeli) care
se lasă liberă deasupra şi dedesubtul ferestrei applet-ului;
HSPACE – valoarea lui este lăţimea zonei (exprimată în pixeli) care se
lasă liberă în stânga şi în dreapta ferestrei applet-ului;
ALT – Specifică textul ce trebuie afişat dacă browser-ul înţelege
marcajul <APPLET> dar nu poate rula applet-uri Java.
NAME – Oferă posibilitatea de a da un nume respectivei instanţe a
applet-ului, astfel încât mai multe applet-uri aflate pe aceeaşi pagină să
comunice între ele folosindu-se de numele lor.
ALIGN – Semnifică modalitatea de aliniere a applet-ului în pagina Web.
Acest atribut poate primi una din următoarele valori: left, right,
top, texttop, middle, absmiddle, baseline, bottom,
8.5. Exemple
97
import javax.swing.*;
import java.awt.*;
98
}
99
import java.awt.Graphics;
import java.awt.Font;
g.setFont (fon);
stil = fon.getStyle();
if ( stil == Font.PLAIN)
str = "Plin";
else if (stil == Font.BOLD)
str = "Bold";
else if (stil == Font.ITALIC)
str = "Italic";
else
str = "Bold italic";
dim = fon.getSize();
str += dim + " puncte ";
nume = fon.getName();
str += nume;
}
}
100
Exemplu 5: Desenează un poligon şi îl copiază într-o altă zonă a ferestrei.
import javax.swing.JApplet;
import java.awt.*;
101
public class app7 extends JApplet {
int xValues[] = {20, 40, 50, 30, 20, 15, 20};
int yValues[] = {20, 20, 30, 50, 50, 30, 20};
102
String sm=getParameter("m"),
sn=getParameter("n");
m=Integer.parseInt(sm);
n=Integer.parseInt(sn);
s=new Integer(m+n).toString();
}
103
9. Interfeţe grafice
În Java există două pachete de clase care oferă servicii grafice: java.awt şi
javax.swing. În acest curs ne vom ocupa de pachetul Swing care este o extensie a
pachetului awt. "Swing" a fost numele de cod dat proiectului care dezvolta
componente noi. Începând cu javax.swing este numele pachetelor pentru Swing
API.
104
Majoritatea obiectelor grafice sunt subclase ale clasei JComponent, clasă
care defineşte generic o componentă grafică care poate interacţiona cu utilizatorul.
Aşadar, printr-o componentă grafică vom înţelege orice obiect care are o
reprezentare grafică ce poate fi afişată pe ecran şi care poate interacţiona cu
utilizatorul. Exemple de componente sunt ferestrele, butoanele, bare de defilare, etc.
În general, toate componentele sunt definte de clase proprii ce se găsesc în pachetul
javax.swing, clasa JComponent fiind superclasa abstractă a tuturor acestor clase.
9.2.1. Exemple
105
12. public void actionPerformed(ActionEvent e) {
13. nrClick++;
14. eticheta.setText(Prefix + nrClick);
15. }
16. });
17. JPanel panou = new JPanel();
18. panou.setBorder(BorderFactory.createEmptyBorder( 3
0,30,10,30));
19. panou.setLayout(new FlowLayout());
20. panou.add(buton);
21. panou.add(eticheta);
22. return panou;
23. }//creazaComponente
24.
25. public static void main(String[] args) {
26. try {
27. UIManager.setLookAndFeel(
UIManager.getLookAndFeel())
;
28. }catch (Exception e) { }
29. JFrame frame = new JFrame("Prima aplicatie
Swing");
30. SwingTest app = new SwingTest();
31. Component comp = app.creazaComponente();
32. frame.getContentPane().add(comp);
33. frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
34. frame.pack();
35. frame.setVisible(true);
36. }//main
37. }//class
106
4. public void init() {
5. JLabel eticheta=new JLabel("O eticheta
frumoasa!");
6. eticheta.setHorizontalAlignment(JLabel.CENTER);
7.
label.setBorder(BorderFactory.createMatteBorder( 1,1,
2,2,Color.black));
8. getContentPane().add(eticheta,
BorderLayout.CENTER);
9. }
10. }
107
9.2.2.3 Manipularea evenimentelor
Aplicaţia din exemplu 1 conţine două evenimente tratate. Una tratează click-ul
pe buton (action events); cealaltă tratează închiderea ferestrei (window events):
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
numClicks++;
label.setText(labelPrefix + numClicks);
}
});
...
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
108
9.3.1. Clasa JFrame
Câteva dintre metodele cele mai folosite ale clasei JFrame sunt prezentate în
continuare.
Metoda pack() este folosită pentru a da o dimensiune frame-ului. O
alternativă pentru pack() este setarea explicită a dimensiunii frame-ului prin
apelarea metodei setSize(). În general, folosirea lui pack() este preferabilă
folosirii lui setSize(), deoarece pack() lasă în seama layout manager-ului calculul
dimensiunii frame-ului care ţine seama şi de alţi factori care pot afecta dimensiunea
componentelor.
Metoda setVisible() este folosită pentru a afişarea frame-ului.
Metoda getContentPane() returnează obiectul contentPane al frame-ului.
Orice componentă se adaugă pe contentPane-ul frame-ului curent.
Exemplu 4:
109
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.pack();
frame.setVisible(true);
}
}
Exemplu 5:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
110
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(
UIManager.getLookAndFeel());
} catch (Exception e) { }
111
JOptionPane.showConfirmDialog – fereastră modală
înzestrată cu două butoane.
Exemplu 7:
JOptionPane.showConfirmDialog(
null,
"Alege un buton",
"Fereastra de confirmare",
JOptionPane.YES_NO_OPTION);
112
Metodele showMessageDialog, showConfirmDialog şi showOptionDialog
returnează un întreg semnificând opţiunea utilizatorului. Valorile acestui întreg pot fi
YES_OPTION, NO_OPTION, CANCEL_OPTION, OK_OPTION şi CLOSED_OPTION.
Exemplu 8:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
frame.pack();
frame.setVisible(true);
}
}
113
9.3.3. Clasa JWindow
}
}
114
9.3.4. Clasa JApplet
115
Pane componentele prea mari.
Split – Afişează două componente într-un spaţiu fix, oferind
Pane utilizatorului posibilitatea să redimensioneze fiecare
componentă.
Tabbed – Conţine mai multe componente dar afişează numai
Pane una la un moment dat. Utilizatorul poate alege între
componente.
Tool – Grupează componentele (în general butoane) într-o
Bar linie sau o coloană, permiţând utilizatorului să o mute
oriunde.
116
for(int i=0;i<100;i++)
t.append(i+"\n");//(new Integer(i)).toString());
import java.awt.*;
import java.awt.event.*;
117
protected Component crearePanel(String text) {
JPanel panel = new JPanel(false);
JLabel label = new JLabel(text);
label.setHorizontalAlignment(JLabel.CENTER);
panel.setLayout(new GridLayout(1, 1));
panel.add(label);
return panel;
}
frame.getContentPane().add(
new AplicTabbed(), BorderLayout.CENTER);
frame.setSize(400, 125);
frame.setVisible(true);
}
}
Un program poate avea interfeţe diferite, chiar dacă sunt folosite aceleaşi
componente. Acest lucru se datorează folosirii a diferiţi gestionari de poziţionare
care controlează dimensiunea şi poziţiile componentelor.
Gestionarea poziţionării este procesul prin care se determină dimensiunea şi
poziţia componentelor. Implicit, fiecare container are un gestionar de poziţionare –
un obiect care gestionează poziţionarea fiecărei componente de pe container. Acest
obiect implementează interfaţa LayoutManager. Acesta poate fi înlocuit cu altul care
să fie pe măsura cerinţelor. În general, se setează gestionarul de poziţionare pentru
118
două tipuri de containere: contentpane (foloseşte implicit BorderLayout) şi
JPanel (foloseşte implicit FlowLayout).
De câte ori se adaugă o componentă pe container trebuie ţinut cont de
gestionarul de poziţionare al containerului respectiv.
De exemplu:
JPanel jp = new JPanel();
jp.setLayout(new BorderLayout());
9.5.1.1 BorderLayout
BorderLayout este layout manager-ul implicit pentru fiecare container
principal. Un BorderLayout are cinci zone în care pot fi aşezate componentele:
nord, sud, est, vest şi centru.
Exemplu 12:
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
119
4. public class AplicBorderLayout extends JFrame{
5. public static void main(String[] args) {
6. AplicBorderLayout f=new AplicBorderLayout();
7. Container contentPane = f.getContentPane();
8. contentPane.setLayout(new BorderLayout());
9. contentPane.add(new JButton("Buton 1 NORD"),
BorderLayout.NORTH);
10. contentPane.add(new JButton("2 CENTRU"),
BorderLayout.CENTER);
11. contentPane.add(new JButton("Buton 3 VEST"),
BorderLayout.WEST);
12. contentPane.add(new JButton("Buton 4 SUD"),
BorderLayout.SOUTH);
13. contentPane.add(new JButton("Buton 5 EST"),
BorderLayout.EAST);
14. f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
15. f.setSize(400, 125);
16. f.setVisible(true);
17. }
18. }
9.5.1.2 BoxLayout
Exemplu 13:
import javax.swing.*;
import java.awt.*;
120
import java.awt.event.*;
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);}
});
f.pack();
f.setVisible(true);
}
}
121
9.5.1.3 CardLayout
Clasa CardLayout permite implementarea unei arii care conţine diferite
componente la momente diferite. Tabbed pane-urile sunt containere intermediare
care furnizează o funcţionalitate similară. Un CardLayout este în general controlat
de un Combo Box, starea lui determinând panel-ul de afişat.
Exemplu 14:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public AplicCardWindow() {
Container contentPane = getContentPane();
contentPane.add(cbp, BorderLayout.NORTH);
cards.add(p1, BUTONPANEL);
cards.add(p2, TEXTPANEL);
contentPane.add(cards, BorderLayout.CENTER);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
122
}
În imaginea următoare se văd cele două stări ale ferestrei în funcţie de starea
Combo Box-ului:
9.5.1.4 FlowLayout
FlowLayout este layout manager-ul implicit pentru orice JPanel. Aşează
componentele de la stânga spre dreapta, de sus în jos.
Exemplu 15:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
123
adaugBut("Buton 3", contentPane);
adaugBut("Buton 4 foarte lung", contentPane);
adaugBut("Buton 5", contentPane);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);}
});
f.pack();
f.setVisible(true);
}
}
Rezultatul execuţiei acestui program este:
9.5.1.5 GridLayout
GridLayout-ul aşează componentele în celulele unui tabel. Fiecare
componentă ocupă tot locul disponibil din celulă. Toate celulele au aceeaşi
dimensiune. La redimesionarea ferestrei GridLayout-ului, celulele îşi vor schimba
dimensiunile astfel încât să fie ocupat tot spaţiul ferestrei.
Clasa GridLayout are doi constructori:
public GridLayout(int rows, int columns)
public GridLayout(int rows, int columns,
int horizontalGap, int verticalGap)
Cel puţin unul din cele două argumente rows şi columns trebuie să fie nenul.
Argumentele horizontalGap şi verticalGap din cel de-al doilea constructor permit
specificarea numărului de pixeli dintre celule. Implicit ele au valoarea 0.
Exemplu 16:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
124
AplicGridLayout f=new AplicGridLayout();
Container contentPane = f.getContentPane();
contentPane.setLayout(new GridLayout(0,2));
contentPane.add(new JButton("Buton 1"));
contentPane.add(new JButton("2"));
contentPane.add(new JButton("Buton 3"));
contentPane.add(new JButton("Buton 4 foarte lung"));
contentPane.add(new JButton("Buton 5"));
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);}
});
f.pack();
f.setVisible(true);
}
}
9.5.1.6 GridBagLayout
GridBagLayout este cel mai sofisticat şi flexibil layout manager pe care
platforma Java îl furnizează. Aşează componentele în celulele unui tabel, fiecare
componentă putând să ocupe mai multe celule. Liniile / coloanele tabelului nu este
obligatoriu să aibă aceeaşi înălţime / lăţime. Pentru fiecare componentă care se
adaugă pe fereastră se setează o serie de constrângeri prin crearea unui obiect al
clasei GridBagConstraints. Aceeaşi instanţă a lui GridBagConstraints
poate fi folosită pentru mai multe componente, chiar dacă ele au constrângeri
diferite. GridBagLayout extrage valorile constrângerilor şi nu refoloseşte
GridBagConstraints. Clasa conţine următoarele atribute care pot fi setate:
125
gridx, gridy – Specifică linia şi coloana colţului din stânga sus a
componentei. Coloana cea mai din stânga are gridx=0 iar linia cea mai de sus are
gridy=0.
gridwidth, gridheight – Reprezintă numărul de coloane (pentru
gridwidth) sau de linii (pentru gridheight) pe care va fi afişată componenta. Valoarea
implicită este 1.
fill – Este folosită atunci când aria de afişare a componentei este mai mare
decât dimensiunea cerută, pentru a determina cum poate fi redimensionată
componenta. Valorile valide sunt:
NONE (implicit),
HORIZONTAL (măreşte componenta pe orizontală astfel încât să
acopere întreaga suprafaţă disponibilă dar nu schimbă înălţimea),
VERTICAL (măreşte componenta pe verticală astfel încât să
acopere întreaga suprafaţă disponibilă dar nu schimbă lăţimea),
BOTH (măreşte componenta astfel încât să acopere întreaga
suprafaţă disponibilă.
ipadx, ipady – Folosite pentru redimensionarea celulelor. Specifică cât
trebuie adunat la dimensiunea minimă a componentei. Valoarea implicită este 0.
Lăţimea / înălţimea va avea valoarea minimă plus ipadx*2 / ipady*2 pixeli (se aplică
în ambele capete ale componentei).
insets – Specifică distanţa dintre componentă şi colţurile suprafeţei pe care
se afişează. Valoarea atribuită este un obiect Insets.
anchor – Este folosită atunci când componenta este mai mică decât suprafaţa
pe care urmează să fie afişată, pentru a determina unde se plasează componenta.
Valori valide sunt CENTER (implicit), NORTH, NORTHEAST, EAST, SOUTHEAST,
SOUTH, SOUTHWEST, WEST şi NORTHWEST.
weightx, weighty – Folosite pentru a determina modul în care să fie
repartizat spaţiul dintre coloane / linii. Dacă nu se specifică nici o valoare (implicit
este 0) atunci toate componentele vor fi grupate în centru container-ului deoarece
GridBagLayout pune orice spaţiu în plus între tabel şi colţurile container-ului.
Exemplu 17:
import java.awt.*;
import java.awt.event.*;
126
import javax.swing.*;
public AplicGridBagLayout() {
JButton buton;
Container contentPane = getContentPane();
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
contentPane.setLayout(gridbag);
if (shouldFill) {
//inaltime implicita, latime maxima
c.fill = GridBagConstraints.HORIZONTAL;
}
127
c.weighty = 1.0; //spatiu vertical intre celule
suplimentar
c.anchor = GridBagConstraints.SOUTH; //componenta va
fi plasata in partea de jos a ferestrei
c.insets = new Insets(10,0,0,0);
c.gridx = 1; //componenta se alinieaza cu
butonul 2
c.gridwidth = 2; //ocupa latimea a doua butoane
c.gridy = 2; //se afla pe a treia linie
gridbag.setConstraints(buton, c);
contentPane.add(buton);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
128
(event listener). Componentele Swing pot genera mai multe tipuri de evenimente.
Câteva dintre interfeţele corespunzătoare ar fi:
129
înregistrată în lista ascultătorilor componentei respective. Am spus listă, deoarece
evenimentele unei componente pot fi ascultate de oricâte clase - cu condiţia ca
acestea să fie înregistrate la componenta respectivă. Înregistrarea unei clase în lista
ascultătorilor unei componente se face cu metode din clasa Component de tipul
addXXXListener, iar eliminarea ei din aceasta lista cu removeXXXListener unde
XXX reprezintă tipul evenimentului.
Componenta.addActionListener(instantaNumeClasa);
Exemplu 18:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
JButton uB,lB,rB;
JPanel pbut;
130
JTextField txt;
Listener lsn;
TextWorker txtWorker;
public AplicEv() {
uB=new JButton("Majuscule");
lB=new JButton("Minuscule");
rB=new JButton("Sterge");
uB.setActionCommand("ActMajuscule");
lB.setActionCommand("ActMinuscule");
pbut=new JPanel();
pbut.add(uB);
pbut.add(lB);
pbut.add(rB);
txt= new JTextField("Introduceti text!");
lsn=new Listener();
getContentPane().setLayout(new BorderLayout());
getContentPane().add("North",txt);
getContentPane().add("Center",lsn);
getContentPane().add("South",pbut);
txtWorker=new TextWorker(txt);
rB.addActionListener(lsn);
uB.addActionListener(lsn);
lB.addActionListener(lsn);
rB.addActionListener(txtWorker);
uB.addActionListener(txtWorker);
lB.addActionListener(txtWorker);
}
public static void main(String[] args) {
AplicEv f=new AplicEv();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.addWindowListener(f.lsn);
f.setSize(400, 125);
//f.pack();
f.setVisible(true);
}
}
131
if(c.equals("Sterge"))
txt.setText("");
if(c.equals("ActMajuscule")){
String oldText=txt.getText();
String uText=oldText.toUpperCase();
txt.setText(uText);
}
if(c.equals("ActMinuscule")){
String oldText=txt.getText();
String lText=oldText.toLowerCase();
txt.setText(lText);
}
}
}
132
9.7. Folosirea componentelor
133
9.7.6. Clasa JRadioButton
Un obiect de tip JList defineşte o listă de opţiuni care poate fi setată astfel
încât utilizatorul să poată selecta o singură opţiune sau mai multe. Toate opţiunile
listei sunt vizibile în limita dimensiunilor grafice ale componentei.
134
1.7. Crearea unui applet...........................................................................5
2. Programarea Orientată pe Obiecte şi Java...............................................7
2.1. Obiecte şi clase.................................................................................7
2.2. Atribute şi comportamente.................................................................8
2.2.1. Atribute..........................................................................................8
2.2.2. Comportament..............................................................................9
2.3. Principiile OOP..................................................................................9
3. Elementele de bază ale limbajului de programare Java.........................11
3.1. Structura lexicală a limbajului..........................................................11
3.1.1. Setul de caractere.......................................................................11
3.1.2. Cuvinte cheie..............................................................................11
3.1.3. Identificatori.................................................................................11
3.1.4. Constante....................................................................................11
3.1.5. Separatori...................................................................................13
3.1.6. Operatori.....................................................................................13
3.1.7. Comentarii...................................................................................17
3.2. Tipuri de date..................................................................................17
3.3. Variabile..........................................................................................18
3.4. Instrucţiuni.......................................................................................20
3.4.1. Instrucţiunea vidă........................................................................20
3.4.2. Instrucţiuni de decizie..................................................................20
3.4.3. Instrucţiuni repetitive...................................................................24
3.5. Tablouri (vectori).............................................................................28
3.5.1. Tablouri (vectori) unidimensionale...............................................28
3.5.2. Tablouri (vectori) cu mai multe dimensiuni..................................30
3.5.3. Dimensiunea unui vector.............................................................30
3.5.4. Tablouri cu dimensiuni variabile..................................................32
3.6. Şiruri de caractere...........................................................................32
4. Clase şi obiecte în Java..........................................................................34
4.1. Referinţe..........................................................................................34
4.2. Obiecte............................................................................................35
4.2.1. Noţiuni generale..........................................................................35
4.2.2. Operatorul de atribuire =.............................................................36
135
4.2.3. Operatorul de egalitate ==...........................................................37
4.3. Clase...............................................................................................38
4.3.1. Definirea claselor........................................................................38
4.3.2. Variabile membru........................................................................40
4.3.3. Metode........................................................................................42
4.3.3.1 Definirea metodelor...............................................................42
4.3.3.2 Modificatorii metodelor...........................................................42
4.3.3.3 Tipul returnat de o metodă.....................................................43
4.3.3.4 Parametrii unei metode..........................................................44
4.3.4. Constructorii unei clase...............................................................45
4.3.5. Obiectul this..............................................................................47
4.3.6. Supraîncărcarea şi supradefinirea metodelor..............................49
4.3.7. Modificatori de acces pentru membrii unei clase.........................50
4.3.8. Membrii instanţă şi membrii clasă...............................................51
4.3.9. Argumente în linia de comandă...................................................53
4.4. Moştenirea......................................................................................56
4.4.1. Principiul moştenirii.....................................................................56
4.4.2. Interfeţe.......................................................................................60
4.5. Probleme.........................................................................................63
5. Pachete..................................................................................................70
5.1. Importul unui pachet, al unei clase sau a unei interfeţe...................71
5.2. Crearea unui pachet........................................................................72
6. Excepţii.............................................................................................77
6.1. Aspecte generale............................................................................77
6.2. Instrucţiunea try...............................................................................78
6.3. Crearea unei excepţii......................................................................80
7. INTRĂRI ŞI IEŞIRI.................................................................................83
7.1. Clasificarea fluxurilor.......................................................................84
7.2. Ierarhia claselor pentru lucru cu fluxuri............................................85
7.2.1. Fluxuri de caractere....................................................................85
7.2.2. Fluxuri de octeţi...........................................................................86
7.3. Superclasele de intrare / ieşire........................................................87
7.4. Crearea unui flux.............................................................................87
136
7.5. Citirea datelor de la tastatură..........................................................88
7.5.1. Obiectul System.in....................................................................88
7.5.2. Clasa InputStreamReader......................................................89
7.5.3. Clasa BufferedReader............................................................90
7.6. Citirea şi scrierea datelor din fişier...................................................91
7.6.1. Clasele FileReader şi FileWriter......................................91
8. APPLET-URI.................................................................................92
8.1. Ce este un applet?..........................................................................92
8.2. Funcţiile unui applet........................................................................94
8.3. Structura generală a unui applet.....................................................94
8.4. HTML..............................................................................................95
8.5. Exemple..........................................................................................97
9. Interfeţe grafice....................................................................................103
9.1. Ce este o interfaţă grafică?...........................................................103
9.2. Primele aplicaţii Swing..................................................................105
9.2.1. Exemple....................................................................................105
9.2.2. Comentarea exemplelor............................................................106
9.2.2.1 Alegerea naturii interfeţei.....................................................106
9.2.2.2 Setarea container-ului principal (din vârful ierarhiei)............107
9.2.2.3 Manipularea evenimentelor..................................................107
9.3. Containere principale....................................................................107
9.3.1. Clasa JFrame...........................................................................108
9.3.2. Ferestre secundare şi clasa JDialog......................................110
9.3.3. Clasa JWindow.........................................................................113
9.3.4. Clasa JApplet.........................................................................114
9.4. Containere intermediare................................................................115
9.5. Folosirea gestionarilor de poziţionare (Layout Manager)...............118
9.5.1. Setarea poziţionării (Layout Manager–ului)...............................119
9.5.1.1 BorderLayout.......................................................................119
9.5.1.2 BoxLayout............................................................................120
9.5.1.3 CardLayout..........................................................................121
9.5.1.4 FlowLayout..........................................................................123
137
9.5.1.5 GridLayout...........................................................................124
9.5.1.6 GridBagLayout.....................................................................125
9.6. Tratarea evenimentelor.................................................................128
9.6.1. Exemplu de tratare a unui eveniment........................................130
9.7. Folosirea componentelor...............................................................132
9.7.1. Clasa JLabel.............................................................................132
9.7.2. Clasa JButton............................................................................133
9.7.3. Clasa JTextField.......................................................................133
9.7.4. Clasa JTextArea........................................................................133
9.7.5. Clasa JCheckBox......................................................................133
9.7.6. Clasa JRadioButton..................................................................133
9.7.7. Clasa JComboBox....................................................................134
9.7.8. Clasa JList................................................................................134
9.7.9. Clasa JScrollBar........................................................................134
138