1.

Elemente introductive
Înţelegem prin tehnologie Java reuniunea dintre un limbaj de programare orientat
obiect şi o platformă dezvoltată de compania Sun Microsystems. Tehnologia Java se bazează
pe conceptul de maşină virtuală Java (JVM- Java Virtual Machine). Toate implementările
existente emulează JVM permiţând astfel unui program Java să ruleze pe orice sistem.
Spre deosebire de alte limbaje de programare, Java utilizează şi compilarea
programelor sursă. Compilarea se efectuează o singură dată şi are ca efect translatarea
programelor sursă într-un limbaj intermediar numit „Java Bytecode”, care nu este altceva
decât limbajul cunoscut de către maşina virtuală Java. Interpretarea are loc de fiecare dată
când programul Java compilat este lansat în execuţie. Interpretorul este o implementare a
maşinii virtuale Java.
Platforma Java este furnizată sub forma a trei versiuni, fiecare în parte, constând în:
• Maşină virtuală Java;
• Java API (API- Application Programming Interface)
• O colecţie bogată de componente software gata de utilizat pentru a uşura
eforturile de dezvoltare de aplicaţii.
Interfaţa de programare (API) Java este compusă din biblioteci cunoscute aici sub
numele de pachete (packages).
Principalul beneficiu adus de tehnologia Java rezidă în portabilitate. Aplicaţiile Java
rulează pe o varietate impresionantă de sisteme hardwareşi sisteme de operare. De asemenea
este un avantaj faptul că limbajul Java este scalabil permiţând astfel realizarea de aplicaţii
pentru dispozitive cu resurse foarte limitate.
Securitatea accesului la informaţie este un alt punct forte al acestei tehnologii, dat
fiind faptul că aceasta este gândită ca o tehnologie pregătită pentru internet (Internet-ready).
Şi nu în ultimul rând Java este o tehnologie deschisă (open), ceea ce duce la o dinamică
ridicată în privinţa extinderii, actualizării şi depanării acesteia.
Limbajul de programare Java a fost folosit la dezvoltarea unor tehnologii dedicate
rezolvării unor probleme din cele mai diverse domenii. Aceste tehnologii au fost grupate în
aşa numitele platforme de lucru, ce reprezintă seturi de librării scrise în Java, precum şi
diverse programe utilitare, folosite pentru dezvoltarea de aplicaţii sau componente destinate
unei anume categorii de utilizatori.
Sun Microsystems a creat trei versiuni de platforme Java: „Standard Edition”,
„Enterprise Edition”, şi „Micro Edition”.

Java 2 Standard Edition (J2SE) cuprinde un sistem de dezvoltare (SDK- System

Developement Kit), unelte(tools), componente „runtime” şi API-uri pentru programatorii
care doresc să scrie aplicaţii în limbajul Java.
De asemenea, aici este inclusă şi tehnologia JavaWeb Start ce furnizează o modalitate
extrem de facilă pentru lansarea şi instalarea locală a programelor scrise în Java direct de pe
Web, oferind cea mai comodă soluţie pentru distribuţia şi actualizarea aplicaţiilor Java.

Java 2 Enterprise Edition (J2EE) îşi propune să simplifice dezvoltarea şi exploatarea

aplicaţiilor complexe de tip multistrat (multitier), prin utilizarea de componente modulare şi
standardizate. Dea semenea, furnizează pentru aceste componente un set complet de servicii
şi reduce efortul de programare prin gestiunea automată a anumitor modele
comportamentale.

1
 Această platformă oferă API-ul necesar dezvoltării de aplicaţii complexe, formate din
componente ce trebuie să ruleze în sisteme eterogene, cu informaţiile memorate în baze de
date distribuite, etc. Tot aici găsim şi suportul necesar pentru crearea de aplicaţii şi servicii
Web, bazate pe componente cum ar fi servleturi, pagini JSP, etc.

Java 2 Micro Edition (J2ME) se adresează segmentului de echipamente de larg

consum. Platforma este scalată corespunzător pentru a face faţă resurselor spartane existente
în aceste echipamente (telefoane, bunuri de uz-casnic etc).

Toate distribuţiile Java sunt oferite gratuit şi pot fi descărcate de pe Internet de la

adresa ”http://java.sun.com”.

Continuând procesul de rafinare, putem observa că fiecare platformă în parte include

o serie de componente, pachete opţionale sau extensii ce vor fi prezentate pe scurt în cele ce
urmează.

Java 2 Standard Edition (J2SE)

Platforma Java 2 Standard Edition (J2SE) include printre altele:
• Java Beans Component Arhitecture: este o specificaţie independentă de platformă
care defineşte un set de API-uri standard pentru componente software.
• Javadoc: este o unealtă pentru a genera documente în format HTML, referitoare la
codul sursă dezvoltat.
• Java Foundation Classes (SWING): reprezintă o colecţie de biblioteci care oferă
suportul necesar construirii interfeţelor grafice utilizator pentru aplicaţii Java.
• Java 2D API: bibliotecă pentru grafică bidimensională şi prelucrarea de imagini.
• Java Database Connectivity (JDBC): este o interfaţă de programare (API) care
permite accesul din Java la baze de date sau alte colecţii de date de tip tabelar (cum ar
fi foile de calcul- spreadsheets).
• Remote Method Invocation (RMI): permite programatorului să creeze aplicaţii Java
distribuite în care metode ale unor obiecte Java aflate la distanţă (remote) pot fi
apelate de către maşini virtuale Java care rulează pe sisteme diferite.
• Java Authenticated and Authorization Service (JAAS): bibliotecă pentru procedurile
de autentificare ale utilizatorilor şi pentru controlul accesului acestora.
• Java Criptography Extension (JCE): bibliotecă pentru implementarea algoritmilor de
criptare a informaţiilor, generarea de chei de criptare şi a algoritmilor de autentificare
a mesajelor.
• Java Media Framework (JMF): permite adăugarea elementelor multimedia (audio,
video etc) aplicaţiilor Java.
• Java Secure Socket Extension (JSSE): bibliotecă pentru comunicarea sigură între
reţele de calculatoare. Implementează, în versiune Java, protocoalele SSL(Secure
Socket Layer) şi TLS (Transport Layer Security). Include funcţiuni pentru criptarea
datelor, autentificarea serverelor, integritatea mesajelor.
• Java Speech API (JSAPI) permite aplicaţiilor Java să încorporeze tehnologii bazate pe
voce în interfeţele utilizator.
• Java 3D este o bibliotecă pentru grafică tridimensională, independentă de platformă.

2
Java 2 Enterprise Edition (J2EE)

• Java API for XML Processing (JAXP) permite procesarea documentelor XML.
• Common Object Request Broker Architecture (CORBA) este un standard deschis
pentru calcul eterogen care completează platforma prin furnizarea unui cadru de lucru
cu obiecte distribuite, de servicii pentru acesta şi interoperabilitate cu alte limbaje.
• Enterprise Java Beans (EJB) utilizează componente model pentru a simplifica
dezvoltarea aplicatiilor prin furnizarea suportului pentru servicii ca tranzacţii,
securitate, conectare la bbaze de date etc.
• Java Mail este o interfaţă de programare (API) care furnizează un set de obiecte
abstracte ce modelează un sistem de poştă electronică.
• Java Messaje Service (JMS) este o API care asigură cadrul pentru dezvoltarea de
aplicaţii portabile, bazate pe mesaje prin definirea unei mulţimi de concepte şi
strategii de programare suportate de toate tehnologiile JMS compatibile.
• Java Server Page (JSP) permite dezvoltatorilor web să producă rapid şi să întreţină
cu uşurinţă pagini web dinamice, independente de platformă. JSP permite ca paginile
să aibă separat partea de interfaţă utilizator de partea de generare de conţinut astfel că
se poate modifica aspectul paginii fără a altera conţinutul acesteia.
• Java Servlets reprezintă modalitatea prin care Java realizează extinderea
capabilităţilor serverelor WEB. Furnizează componente pentru dezvoltarea de
aplicaţii WEB fără limitările impuse de programarea CGI (Common gateway
Interface).

Java 2 Micro Edition (J2ME)

• Connected Limited Device Configuration (CLDC) pregăteşte mediul de execuţie java

pentru a fi potrivit dispozitivelor ce conţin resurse limitate specifice platformei J2ME.
CLDC conturează setul de biblioteci de bază şi caracteristicile maşinii virtuale care
trebuie să existe în implementarea respectivului mediu J2ME.
• Mobile Information Device Profile (MIDP) furnizează nucleul de funcţionalitate al
aplicaţiei incluzând interfaţa utilizator, conectarea la reţea, memorarea de date.
• Connected Device Configuration (CDC) reprezintă un cadru de lucru standard pentru
construirea şi distribuirea aplicaţiilor care pot fi partajate peste o reţea de
comunicaţie.

Setul de caractere
Limbajului Java lucrează în mod nativ folosind standardul Unicode. Unicode
înlocuieşte vechiul standard ASCII pentru reprezentarea caracterelor. Astfel devine posibilă
reprezentarea a mai mult de 256 de caractere pentru ca Unicode utilizează 16 biţi în acest
scop. Vechiul standard ASCII se regăseşte însă ca un subset al setului Unicode.
Java foloseşte standardul Unicode atât în timpul rulării aplicaţiilor cât şi în timpul
compilării acestora. Compilatorul Java acceptă la intrare fişiere sursă care pot conţine orice
caractere Unicode.

3
 Primele 256 caractere Unicode corespund celor ASCII, referirea la celelalte făcându-
se prin \uxxxx, unde xxxx reprezintă codul caracterului.
O altă caracteristică a setului de caractere Unicode este faptul că întreg intervalul de
reprezentare a simbolurilor este divizat în subintervale numite blocuri, câteva exemple de
blocuri fiind: Basic Latin, Greek, Arabic, Gothic,Currency, Mathematical, Arrows, etc.
Iată câteva exemple de caractere Unicode.
• \u0030 - \u0039 : cifre ISO-Latin 0 - 9
• \u0660 - \u0669 : cifre arabic-indic 0 - 9
• \u03B1 - \u03C9 : simboluri greceşti _ − !
• \u2200 - \u22FF : simboluri matematice (8, 9, ;, etc.)
• \u4e00 - \u9fff : litere din alfabetul Han (Chinez, Japonez, Coreean)
Mai multe informaţii legate de reprezentarea Unicode pot fi găsite pe Internet la
adresa ”http://www.unicode.org”.

Cuvinte cheie. Cuvinte rezervate

Cuvintele cheie sunt şiruri de caractere rezervate de limbaj pentru uzul propriu. Nici
un program nu poate să utilizeze aceste cuvinte pentru un alt scop decât cel definit de limbaj.
Cuvintele cheie însa pot aparea în şiruri de caractere sau comentarii. Cuvintele îngroşate din
lista următoare reprezintă cuvintele cheie ale limbajului. Celelalte sunt cuvinte rezervate. Ele
nu au nici o semnificaţie în Java însa nu pot fi folosite pe post de identificatori.

abstract boolean break byte

case cast catch char
class const continue default
do double else extends
final finally float for
future generic goto if
instance
implements import inner
of
intinterfac
long native new
e
null operator outer package
private protected public rest
return short static super
synchroniz
switch this throw
ed
throws transient try var
void volatile while byvalue

4
Identificatori
Identificatorii Java sunt şiruri de caractere (litere şi cifre) Unicode, nelimitate, care încep
obligatoriu cu o literă. Se interzice folosirea unui cuvânt cheie pe post de identificator.
Exemple:

contor
f2
index

Literali
Un literal este o valoare specificată în fişierul sursă pentru tipurile de date primitive sau şir de
caractere. În limbajul Java există următoarele tipuri de literali:
• literali booleeni
• literali caracter
• literali întregi
• literali flotanţi
• literali şir de caractere

Literalii booleeni nu pot fi decât true sau false, primul reprezentând valoarea booleană
de adevăr iar celălalt valoarea booleană de fals. true şi false nu sunt cuvinte rezervate ale
limbajului Java, cu toate acestea ele nu vor putea fi folosite ca identificatori.

Un literal de tip caracter poate fi formulat simplu prin încadrarea caracterului dorit între
apostrofuri. Această tehnică este valabilă numai dacă respectivul caracter se regăseşte pe
tastatură. Exemplu:
char c = 'w';
Este posibil să formulăm literali de tip caracter specificând codul Unicode al caracterului
dorit sub forma a 4 cifre hexazecimale precedate de secvenţa \u. Exemplu:
char c = '\u23a7';

5
Java suportă de asemenea şi câteva secvenţe speciale, numite secvenţe de escape, pentru
denotarea unor caractere speciale:
'\b' caracterul Backspace
'\t' caracterul TAB orizontal
'\n' caracterul LineFeed (LF)
'\f' caracterul FormFeed (FF)
'\r' caracterul Carriage Return (CR)
'\"' caracterul ghilimele
'\'' caracterul apostrof
'\\' caracterul Backslash
Literalii întregi pot fi reprezentaţi în baza 10, 16 sau 8. Baza de numeraţie zecimală este
considerată implicit. Pentru a indica un literal octal acesta se prefixează cu 0 (zero). Literalii
hexazecimali se prefixează cu 0x sau 0X. Cifrele hexazecimale litere pot fi scrise atât cu
litere mici cât şi cu majuscule (case insensitive). Exemple:
• 28 – literal întreg exprimat în baza de numeraţie zecimală
• 034 – literal întreg exprimat în baza de numeraţie octală
• 0x1c – literal întreg exprimat în baza de numeraţie hexazecimală
• 0x1C – literal întreg exprimat în baza de numeraţie hexazecimală
• 0X1c – literal întreg exprimat în baza de numeraţie hexazecimală
• 0X1C – literal întreg exprimat în baza de numeraţie hexazecimală
Implicit un literal întreg este reprezentat pe 32 de biţi. Pentru a indica faptul că este vorba de
un literal reprezentat pe 64 de biţi (long) se adaugă sufixul L. Poate fi utilizată şi litera mică
l, însa acest lucru nu este de dorit datorită faptului ca adesea se confundă cu cifra 1.
Exemple:
1234L sau 5678l
Literalii flotanţi (sau virgulă mobilă) reprezintă numere reale. Pentru ca o expresie să fie
interpretată ca literal flotant ea trebuie să conţină unul din următoarele:
• punct zecimal. Exemplu: 3.1415926
• litera E sau e. Exemplu: 4.1E+10
• sufixul F sau f, indicând o reprezentare pe 32 de biţi. Exemplu: 1.56f
• sufixul D sau d, indicând o reprezentare pe 64 de biţi. Exemplu: 1234d

6
Dacă nu este specificat nici un sufix, valoarea este implicit reprezentată pe 64 de biţi.

Un literal şir de caractere constă într-o secvenţă de caractere încadrată de ghilimele.

Secvenţa de caractere poate conţine caractere obişnuite sau secvenţe de escape ca cele
definite la literalii caracter. Exemplu:
String s = ”Secventa de caractere”;

Separatori
Separatorii sunt caractere folosite pentru a delimita diversele elemente (unităţi lexicale) ale
limbajului. Separatorii participă în acelaşi timp şi la construcţia sintaxei limbajului. Ei nu au
un rol identic cu spaţiile deşi, ca şi acestea, separă unităţi lexicale diferite. În Java separatorii
sunt următorii:
( ) { } [ ] ; , .

Exemple:
v[i]
functie(x)

Comentarii
Un comentariu este o secvenţă de caractere existentă în fişierul sursă care serveşte numai la
explicarea sau documentarea programului şi nu afectează în nici un fel funcţionarea acestuia.
În Java există trei feluri de comentarii:
• Comentarii care se întind pe mai multe linii. Acestea sunt încadrate de secvenţele /*
şi */
• Comentarii pe mai multe linii care vor fi prelucrate de către generatorul automat de
documentaţie. Acestea sunt încadrate de secvenţele /** şi */
• Comentarii pe o singură linie. Acestea încep cu // şi conţin caracterele care urmează
acestei secvenţe până la sfârşitul liniei.
În Java, nu putem să scriem comentarii în interiorul altor comentarii. De asemenea, nu putem
introduce comentarii în interiorul literalilor caracter sau şir de caractere. Secvenţele /* şi */
pot să apară pe o linie după secvenţa // dar îşi pierd semnificaţia. La fel se întâmplă cu
secvenţa // în comentarii care încep cu /* sau /**. Exemple:
/* Comentariu
care se intinde

7
 pe mai multe randuri */
/** Comentariu ce va fi preluat
de generatorul de documentatie */
// Comentariu pe un singur rand

Operatori
Operatorii reprezintă simboluri grafice pentru operaţiile elementare definite de limbajul Java.
Totodtă operatorii joacă şi rol de separatori. În tabelul următor sunt prezentaţi operatorii
elementari ai limbajului Java în ordinea descrescătoare a precedenţei.
Unari ++ -- + - ! ~ ()
* / %
Aritmetici
+ -
Deplasare << >> >>>
< <= > >=
Comparare
== !=
Pe bit & ^ |
Logici && ||
Condiţionali ?:
Atribuire = op=

În Java, spre deosebire de alte limbaje de programare, ordinea de evaluare a operanzilor într-
o expresie este fixă. Astfel întotdeauna toţi operanzii sunt evaluaţi de la stânga la dreapta.
Operatorii unari lucrează asupra unui singur operand. In continuare sunt descrişi operatorii
unari elementari ai limbajului Java.
Operatorii de incrementare şi decrementare: ++ respectiv --
Modifică valoarea unei expresii adăugandu-i sau scăzându-i valoarea 1. Spre exemplu dacă x
are valoarea 10, atunci ++x va face ca x să aiba valoarea 11, in vreme ce --x va face ca x
sa aiba valoarea 9.
Operatorii ++ şi -- pot fi plasaţi atât înaintea expresiei (ca în exemplul precedent) cat şi
după aceasta. Pentru a înţelege efectul plasării într-un fel sau altul al acestor operatori să
considerăm exemplele următoare:

(1) y = x++
(2) y = ++x

8
Presupunând ca x are iniţial valoarea 10, valoarea lui y va fi în primul caz 10, iar în al
doilea 11 (vezi ordinea evaluarii operanzilor). În ambele cazuri însă, valoarea lui x va
deveni 11.
Operatorii + şi –
Trebuie facută distincţie între aceşti operatori şi operatorii aritmetici de adunare, respectiv
scădere. Operatorul + nu are nici un efect asupra valorii operandului său, în vreme ce
operatorul – va schimba semnul acestuia.
Operatorul de complementare pe bit ~
Acest operator acţionează la nivelul reprezentării binare a operandului său transformând
cifrele 1 ale reprezentarii sale în cifre 0 şi invers. Astfel dacă am aplica acest operator asupra
unui operand reprezentat pe un octet cu valoarea 00110011 rezultatul obţinut ar fi
11001100.
Operatorul boolean de complementare !
Complementează valoarea unei expresii booleene. Astfel !true va fi da false iar
!false va da true.

Operatorii de înmulţire şi împarţire * şi /

Aşa cum arată chiar numele lor efectuează operaţiile de înmulţire, respectiv împarţire între
doi operanzi. Folosirea lor presupune înţelegerea limitărilor impuse de formatul de
reprezentare al operanzilor. De pildă dacă vom înmulţi doi operanzi întregi rezultatul se va
calcula conform regulilor aritmeticii numerelor întregi, însă având în acelaşi timp grija ca
rezultatul obţinut să nu depăşească formatul de reprezentare. Dacă acest lucru se întâmplă
atunci valoarea obţinută pentru rezultat nu va avea semnificaţia corectă.
Operatorul modulo %
Semnificaţia rezultatului unei operaţii modulo este aceea de rest al unei împărţiri întregi.
Astfel dacă, de exemplu, vom efectua împărţirea întreagă a lui 7 la 4 vom obţine câtul 1 şi
restul 3. Acest lucru îl scriem in Java sub forma expresiei 7 % 4, iar valoarea acesteia va fi
3.
Deşi pare natural să aplicăm acest operator numai asupra unor operanzi întregi, în Java este
posibil să îl folosim şi cu operanzi numere reale.
Regula după care se obţine rezultatul operaţiei modulo în Java este următoarea:
1. Se micşorează valoarea absolută a primului operand (din stânga) cu valoarea absolută
a celui de-al doilea operand (din dreapta)

9
 2. Se repeta pasul 1 până când valoarea absolută a rezultatului obţinut la pasul 1 este
este mai mică decât valoarea absolută a celui de-al doilea operand (cel din dreapta).
Această ultimă valoare este rezultatul operaţiei modulo.
Pentru exemplificare considerăm următoarele cazuri:
(1) 17 % 5
17 – 5 = 12
12 – 5 = 7
7 – 5 = 2
2 < 5 STOP. Rezulta ca 17 % 5 = 2
(2) 7.6 % 2.9
7.6 – 2.9 = 4.7
4.7 – 2-9 = 1.8
1.8 < 2.9 STOP. Rezulta ca 7.6 % 2.9 = 1.8
(3) -5 % 2
Ca sa micsoram valoarea absoluta cu 2 trebuie sa
efectuam adunari
-5 + 2 = -3
-3 + 2 = -1
Valoarea absoluta a lui -1 este 1,
iar 1 < 2. STOP. Rezulta ca -5 % 2 = -1
(4) -5 % -2
-5 + 2 = -3
-3 + 2 = -1
Valoarea absoluta a lui -1 este 1,
iar 1 < 2. STOP. Rezulta ca -5 % -2 = -1
Operatorii de adunare şi scadere + şi –
Efectuează adunarea, respectiv scăderea operanzilor. Se aplică operanzilor de tip numeric
indiferent de tip. De asemenea folosirea acestor operatori presupune înţelegerea limitărilor
impuse de formatul de reprezentare al operanzilor, altfel rezultatul obţinut este unul fară o
semnificaţie corectă.
Deplasarea este o operaţie care acţionează la nivelul reprezentării unui număr. Pe scurt
reprezentarea binară operandului număr este deplasata spre stânga sau spre dreapta cu un
anumit numar de poziţii (ranguri binare). Operatorii de deplasare se pot aplica numai

10
operanzilor de tip întreg. Mecanismul de bază al operaţiilor de deplasare este ilustrat in
figurile următoare.
Valoare operand: 192
Reprezentare
00000000 00000000 00000000 11000000
binară
Deplasare
spre stânga 0 00000000 00000000 00000001 1000000?
cu 1 poziţie
Deplasare
spre dreapta ?0000000 00000000 00000000 01100000 0
cu 1 poziţie
Deplasare
spre stânga 0000 00000000 00000000 00001100 0000????
cu 4 poziţii

Valoare operand: –192

Reprezentare
11111111 11111111 11111111 01000000
binară
Deplasare
spre stânga 1 11111111 11111111 11111110 1000000?
cu 1 poziţie
Deplasare
spre dreapta ?1111111 11111111 11111111 10100000 0
cu 1 poziţie

Urmărind exemplele de mai sus se ridică două întrebări:

(1) Pentru că rezultatul operaţiei de deplasare va avea acelaşi număr de biţi la nivelul
reprezentării, ce se întîmplă cu biţii care „părăsesc” formatul de reprezentare (valorile
0 sau 1 îngroşate) ?
(2) Ce valori vor avea biţii care sunt introduşi in reprezentarea rezultatului (cei marcaţi
prin semne de întrebare) ?
Prima întrebare are un răspuns foarte simplu, biţii care „părăsesc” formatul de reprezentare
sunt ignoraţi, deci se pierd. Cea de-a doua însă presupune discutarea mai multor situaţii.
Astfel, în cazul operatorilor de deplasare spre stânga << şi deplasare spre dreapta fără semn
>>>, biţii cei noi vor avea valoarea 0. În cazul deplasării spre dreapta cu semn >>, biţii cei
noi vor lua valoarea avută de cel mai semnificativ bit din reprezentare, înainte de operaţia de
deplasare. Revenind la exemplele precedente, în cazul deplasării spre dreapta a numarului
192 valoarea bitului nou introdus va fi 0, în vreme ce aceeaşi operaţie de deplasare efectuată
asupra lui –192 va determina introducerea unui bit 1 în formatul de reprezentare.

11
Aplicarea operatorilor de comparare (<,<=,>,>=,== şi !=) duce la obţinerea unui rezultat
boolean; cu alte cuvinte expresia care conţine aceşti operatori poate avea valoarea true sau
false. Semnificaţia acestor operatori este:
• < – mai mic
• <= – mai mic sau egal
• > – mai mare
• >= – mai mare sau egal
• == – egal
• != – diferit
Există trei tipuri de comparare. Primul tip este compararea ordinală cu ajutorul căreia testăm
relaţia între valorilor operanzilor numerici. Al doilea tip este comparare obiectuală utilizat
atunci când dorim să testăm, de pildă, dacă un obiect este de un anumit tip. Al treilea tip îl
reprezintă testul de egalitate cu ajutorul căruia testăm identitatea a două valori. Testul de
egalitate poate fi aplicat şi asupra operanzilor ne-numerici.
Exemple:
int p = 9;
int q = 65;
int r = -12;
float f = 9.0;
char c = 'A';
următoarele operaţii de comparare vor avea rezultatul true.
p < q
f < q
f <= c
c > r
c >= q

Operatorii pe bit &, ^ şi | se utilizează împreună cu operanzi întregi. Aceşti operatori oferă
posibilitatea de a efectua operaţiile AND, XOR respectiv OR între reprezentările binare ale
operanzilor. Exemple:
00110011
11110000
AND ––––––––
00110000
00110011
11110000
XOR ––––––––
11000011

12
 00110011
11110000
OR ––––––––
11110011

Operatorii logici sau booleeni, && şi ||, se utilizează împreună cu operanzi booleeni
efectuând operaţiile logice AND respectiv OR între aceştia. Nu trebuie confundaţi cu
operatorii pe bit care implementează aceleaşi operaţii logice pentru că tipul operanzilor este
diferit.
Operatorul condiţional ?:, cunoscut şi sub numele de operator ternar, oferă un mijloc simplu
şi eficient de a codifica in Java o condiţie sub forma unei singure expresii. Forma acesteia
este:
e1 ? e2 : e3
Mai întâi este evaluată expresia e1, care trebuie să fie o expresie booleană. Dacă aceasta este
true, rezultatul expresiei de mai sus este dat de valoarea expresiei e2. În caz contrar
expresia va avea ca rezultat valoarea lui e3. Exemplu:
a = x ? b : c;
Operatorul de atribuire asignează o valoare unei variabile. Operatorul simplu de atribuire este
=, însă în Java există si operatorii compuşi de tip „Calculează şi atribuie” de forma op=.
Pentru două expresii compatibile x şi y, expresia
x op= y este echivalentă cu x = x op y.
Toţi operatorii discutaţi până acum produceau o valoare ca urmare a aplicarii lor asupra unor
operanzi. În Java atribuirea este de asemenea considerată operator deoarece are o valoare
rezultat. Astfel în Java instrucţiunea a=b=c=0; este perfect valabilă. Ea este executată de la
dreapta la stînga începând deci prin a asigna valoarea 0 lui c. După executarea acesteia
expresia c = 0 ia o valoare (care este evident 0 în acest exemplu) ce va fi atribuită mai
departe lui b.

Variabile. Declaraţii de variabile

O variabilă identifică o zonă de memorie care poate stoca o valoare de un anumit tip. Chiar
dacă se numesc variabile există cazuri în care nu este permisă modificarea valorii acestora,
situaţie în care avem de-a face cu aşa-numitele variabile finale. Orice variabilă trebuie să fie
declarată pentru a putea fi folosită. Această declaraţie trebuie să specifice tipul valorilor care

13
pot fi stocate în zona de memorie rezervată variabilei şi de asemenea un nume pentru
variabila declarată. În forma cea mai simplă, declaraţia unei variabile arată în felul următor:
Tip NumeVariabila [, NumeVariabila] ;
Numele variabilei declarate este un identificator Java. Tipul unei variabile poate fi fie unul
dintre tipurile primitive definite de limbajul Java fie o referinţă. În Java este definită foarte
exact modalitatea de reprezentare a acestor tipuri primitive în memorie realizându-se astfel
independenţa de platforma hardware şi software pe care se lucrează. De asemenea sunt
definite valori implicite pentru fiecare tip de dată, în cazul în care aceastea nu au fost
iniţializate de către utilizator, cunoscându-se astfel întotdeauna valoarea cu care o variabilă
intră în calcul. În Java putem iniţializa variabilele chiar în momentul declarării acestora:
Tip NumeVariabila = ValoareInitiala ;
Valoarea iniţială trebuie să fie de acelaşi tip cu tipul variabilei sau să poată fi convertită într-o
valoare de acest tip.
O varibilă de un tip primitiv conţine o singură valoare cu dimensiune şi format corespunzător
tipului său de date: numeric, caracter sau boolean. De exemplu, o valoare întreagă este
reprezentată pe 32 de biţi în cod complement faţă de 2.
În tabelul următor sunt prezentate toate tipurile primitive de date, suportate de Java,
incluzând formatul de reprezentare al acestora.

Cuvânt
Descriere Format de reprezentare
cheie
(numere întregi)
byte întreg reprezentat pe octet 8-biţi, complement faţă de 2
short întreg scurt 16-biţi, complement faţă de 2
int întreg 32-biţi, complement faţă de 2
long întreg lung 64-biţi, complement faţă de 2
(numere reale)
float virgulă mobilă – simplă precizie 32-biţi, IEEE 754
double virgulă mobilă – dublă precizie 64-biţi, IEEE 754
(alte tipuri)
char caracter 16-biţi, cod Unicode

boolean boolean (logic) true sau false

Valorile implicite pe care le vor avea variabilele neiniţializate sunt:

14
 Valoare Interval de valori
Tip primitiv
implicită
-128
byte 0 ...
+127
-32767
short 0 ...
+32768
-2147483648
int 0 ...
2147483647
-9223372036854775808
long 0 ...
9223372036854775807
float 0 conform standard IEEE 754
double 0 conform standard IEEE 754
char \u0000 –
boolean false {true, false}

Observaţii:
1. Standardul IEEE 754 defineşte pe lângă formatul de reprezentare în virgulă mobilă
simplă şi dublă precizie şi o serie de valori speciale. Prima dintre acestea este NaN
(Not A Number), valoare care se obţine atunci când efectuăm o operaţie a cărei
rezultat nu este definit, de exemplu 0.0/0.0. De asemenea sunt definite două valori pe
care le putem folosi pe post de infinit pozitiv şi negativ. Aceste valori sunt prezente în
limbajul Java sub formă de constante predefinite cu numele NaN,
POSITIVE_INFINITY, respectiv NEGATIVE_INFINITY.
2. Pentru tipurile de date întregi, întregi lungi şi pentru tipurile flotante există definite
câte două constante care reprezintă valorile minime şi maxime care se pot reprezenta
în tipurile respective. Aceste două constante se numesc în mod uniform MIN_VALUE
şi MAX_VALUE.
Exemple de declaraţii de variabile:
boolean gata;
boolean corect;
char caracterCitit;
byte nrCulori;

15
 short i=0, j, varstă;
int salariu = 10000000;
float raport;
double nrMolecule;
Domeniul de existenţă reprezintă o secţiune de program în care o variabilă poate fi referită
direct numai prin numele său. Totodată, domeniul de existenţă determină modul în care
sistemul alocă sau şterge zonele de memorie rezervate variabilelor precum şi regulile de
vizibilitate ale acestora. Astfel va fi precizat dacă şi cum o variabilă poate fi utilizată în afara
domeniului de existenţă.

Expresii, instrucţiuni, blocuri

Variabilele şi operatorii descrişi în subcapitolele anterioare reprezintă elementele de bază cu
care ne elaborăm programele. Astfel, combinăm literali, variabile şi operatori pentru a forma
expresii (fragmente de cod care efectuează calcule şi returnează valori), anumite expresii se
pot constitui ca instrucţiuni (unităţi de execuţie complete), iar prin gruparea mai multor
instrucţiuni obţinem blocuri de instrucţiuni sau de cod.
Expresiile sunt folosite pentru a calcula şi atribui valori variabilelor şi pentru a facilita
controlul execuţiei programului. Astfel rezultă dublul rol pe care îl are de îndeplinit o
expresie: efectuarea calculelor indicate de elementele expresiei şi returnarea unei valori ca
rezultat al calculelor efectuate. Tipul valorii returnate de o expresie depinde de elementele
utilizate în cadrul expresiei.
Limbajul de programare Java permite construirea de expresii compuse atâta vreme cât
tipurile de date necesare unei părţi a expresiei se potrivesc cu tipurile de date ale restului
acesteia. Exemplu:
x * y * z
În acest exemplu particular ordinea în care expresia este evaluată nu este importantă pentru
că operaţia de înmulţire este una asociativă. Acest lucru nu este valabil însă pentru orice
expresie. Rezultatul poate diferi mult în funcţie de ordinea de evaluare a expresiei. Această
ordine poate fi controlată riguros prin utilizarea parantezelor rotunde. Exemplu:
x + y / 100
(x + y) / 100
Dacă nu se indică explicit ordinea de evaluare prin utilizarea parantezelor rotunde, atunci
aceasta se determină ţinând cont de precedenţa operatorilor utilizaţi; cei cu precedenţa cea
mai mare fiind evaluaţi primii. De exemplu cele două expresii de mai jos sunt echivalente:
x + y / 100
x + (y / 100)

16
Când în aceeaşi expresie avem de-a face cu operatori cu aceeaşi precedenţă atunci regula de
evaluare este:
• Toţi operatorii binari, cu excepţia atribuirii, se evaluează în ordine de la stânga la
dreapta.
• Operatorii de atribuire sunt evaluaţi în ordine de la dreapta la stânga
Instrucţiunile formează unităţi de execuţie complete. Următoarele tipuri de expresii pot fi
transformate în instrucţiuni prin adăugarea la sfârşitul expresiei a separatorului ;.
• atribuirea
• incrementarea ++ sau decrementarea --
• apelurile de subprograme
• crearea de obiecte
Exemple:
valoare = 1234.56;
valoare++;
System.out.println(valoare);
În plu, există instrucţiuni de declarare cu ajutorul cărora se efectuează declaraţiile de
variabile. Exemplu:
double valoare = 1234.56;
În sfârşit, există şi instrucţiunile pentru controlul execuţiei programului care vor determina
ordinea în care vor fi executate instrucţiunile programului. Aici intră instrucţiunile de
ramificare şi instrucţiunile de ciclare (sau de buclare).
Un bloc reprezintă un grup de zero sau mai multe instrucţiuni cuprinse între acolade. Un bloc
poate fi utilizat oriunde este permisă utilizarea unei instrucţiuni simple. Exemplu:
{
valoare = 1234.56;
valoare++;
System.out.println(valoare);
}
Fără a efectua nici un control al execuţiei programului, instrucţiunile acestuia ar fi executate
secvenţial în ordinea în care ele apar de sus în jos şi de la dreapta la stânga. Instrucţiunile
pentru controlul execuţiei programului pot schimba ordinea în care se execută instrucţiunile
funcţie de anumite condiţii specificate. Limbajul Java furnizează astfel de instrucţiuni,
rezumate în tabelul următor:

Tipul instrucţiunii Cuvinte cheie

de ciclare while, do-while, for

17
 de ramificare if-else, switch-case
de tratare a excepţiilor try-catch-finally, throw
de salt break, continue, label:,
return

Sintaxa generală a instrucţiunii do-while este:

do {
instructiuni
} while (expresieBooleana);
Spre deosebire de instrucţiunea while care începea cu evaluarea expresiei booleene,
instrucţiunea do-while trece o dată prin corpul ciclului după care evaluează expresia
booleană. Dacă expresia booleană returnează valoarea true ciclul se reia. Procesul continuă
până când valoarea returnată de expresia booleană devine false. Şi instrucţiunea do-
while face parte din categoria instrucţiunilor de ciclare cu număr necunoscut de paşi, însă
spre deosebire de while, aceasta este în acelaşi timp o instrucţiune de ciclare cu test final.
Acest lucru face ca blocul de instrucţiuni care compune corpul ciclului să fie executat cel
puţin o dată.
Exemplu:
int i = 0;
do {
System.out.println("Text");
i++;
} while (i < 5)

Instrucţiunea for ne oferă un mijloc de a efectua iteraţii peste un interval de valori. Forma
generală a instrucţiunii for este:
for (instructiune; conditie; expresie) {
instructiuni
}
Execuţia instrucţiunii for se bazează pe următoarele reguli:
• se incepe prin executarea instrucţiunii instructiune. Aceasta este utilizată de
obicei pentru a iniţializa variabilele contor pe baza cărora se face iterarea.
• conditie trebuie să fie o expresie booleană şi este tratată exact ca
expresieBooleana din instrucţiunea while, adică se va executa repetat corpul
ciclului cât timp conditie rămâne true. Şi aici, la fel ca la instrucţiunea while
este posibil ca să nu se execute niciodată corpul ciclului dacă la începutul ciclului
conditie este deja false.

18
 • expresie este executată imediat după executarea corpului ciclului dar înainte de
testarea din nou a expresiei conditie. De obicei expresie se foloseşte pentru a
incrementa variabilele contor.
Exemplu:
int i;
for (i = 0; i < 10; i++) {
System.out.println("Text");
}
Observaţii:
1. Oricare dintre instructiune, conditie sau expresie poate fi omisă. Dacă
partea care lipseşte este conditie atunci se obţine un ciclu infinit. Exemplu:
for ( ; ; ) {
...
}
2. instructiune şi expresie pot conţine în loc de o expresie, secvenţe de
expresii. Separarea acestor expresii din secvenţă se face cu ajutorul separatorului
virgulă şi nu cu punct-şi-virgulă deja folosit in sintaxa lui for pentru a delimita cele
trei părţi ale sale instructiune, conditie respectiv expresie.
Exemplu:
int j,k;
for (j=3, k=6; j+k < 20; j++, k+=2) {
...
}
3. Instrucţiunea for este o instrucţiune de ciclare cu număr cunoscut de paşi şi în acelaşi
timp instrucţiune de ciclare cu test iniţial.
Instrucţiunea if/else permite execuţia selectivă a secvenţelor de program Java, în funcţie
de anumite criterii. Există două forme pentru instrucţiunea if/else. Prima dintre acestea are
următoarea sintaxă:
if (expresieBooleana) {
instructiuni
}
Secvenţa instructiuni se va executa dacă expresieBooleana are valoarea true.
Cea de-a doua formă a instrucţiunii if/else permite executarea unei secvenţe de
instrucţiuni şi în cazul în care expresia booleană are valoarea false. Sintaxa acesteia este:
if (expresieBooleana) {
instructiuni_1

19
 } else {
instructiuni_2
}
Dacă expresieBooleana are valoarea true se va executa secvenţa
instructiuni_1. Dacă dimpotrivă expresieBooleana ia valoarea false se va
executa secvenţa instrucţiuni_2.
Exemplu:
if (raspuns == OK) {
System.out.println("Raspunsul a fost OK");
} else {
System.out.println("Raspunsul nu a fost OK");
}
Atunci când avem nevoie să efectuăm o alegere şi aceasta se poate face în funcţie de o
valoare întreagă rezolvarea o constituie instrucţiunea switch. Sintaxa instrucţiunii este:
switch(expresieIntreaga) {
case valoareIntreaga1:
instructiuni_1
break;
case valoareIntreaga2:
instructiuni_2
break;
...
case valoareIntreagaK:
instructiuni_K
break;
default:
instructiuni
break;
}
Executarea instrucţiunii switch începe prin a evalua expresieIntreaga. Se identifica
apoi case-ul a cărui eticheta valoareIntreaga este egală cu valoarea lui
expresieIntreaga şi se execută secvenţa de instrucţiuni asociată acestuia.
Observaţii:
1. Execuţia secvenţei de instrucţiuni se opreşte la prima instrucţiune break întâlnită.
2. Eticheta default are asociată secvenţa de instrucţiuni care se execută atunci când
niciunul dintre case-uri nu a fost selectat.
3. Instrucţiunea switch este echivalentă cu o succesiune de instrucţiuni if/else.
Exemplu:
switch(zi) {
case 1:
System.out.println("Luni");
break;

20
 case 2:
System.out.println("Marti");
break;
case 3:
System.out.println("Miercuri");
break;
case 4:
System.out.println("Joi");
break;
case 5:
System.out.println("Vineri");
break;
case 6:
System.out.println("Sambata");
break;
case 7:
System.out.println("Duminica");
break;
}
Instrucţiunea break are două forme: etichetată şi neetichetată. Forma neetichetată a
instrucţiunii break face ca execuţia celei mai din interior construcţie switch, for,
while sau do-while, care conţine break-ul, să se incheie.
Exemplu: Instrucţiunea break determină incheierea execuţiei ciclului for 2.
for ( ; ; i++) { // ciclu for 1
for ( ; ; j++) { // ciclu for 2
if (gata) {
....
break;
}
}
}
Forma etichetată a instrucţiunii break face ca să se încheie execuţia instrucţiunii identificată
printr-o eticheta specificată ca argument al lui break. O etichetă constă într-un identificator
plasat înaintea unei instrucţiuni separată de aceasta prin caracterul ´:´.
eticheta: instructiuneJava;
Exemplu: Instrucţiunea break etichetată determină incheierea execuţiei ciclului for 1.
aici:
for ( ; ; i++) { // ciclu for 1
for ( ; ; j++) { // ciclu for 2
if (gata) {
....
break aici;
}
}
}

21
Instrucţiunea continue are ca efect trecerea peste iteraţia curentă a unei instrucţiuni for,
while sau do-while. continue are de asemenea două forme: etichetată respectiv
neetichetată. Forma neetichetată are efect asupra celei mai din interior instrucţiuni de ciclare
care o conţine, în vreme ce forma etichetată va acţiona asupra instrucţiunii de ciclare
identificată prin eticheta specificată ca argument al instrucţiunii continue.
Exemplu:
for (int i = 0; i < max; i++) {
...
if (nuEsteZero)
continue;

// contorizare 0-uri
numarZerouri++;
}

Vectori
Crearea unui vector presupune realizarea următoarelor etape:
• Declararea vectorului - Pentru a putea utiliza un vector trebuie, înainte de toate, sa-l
declarăm. Acest lucru se face prin expresii de forma:
Tip[] numeVector; sau
Tip numeVector[];
ca în exemplele de mai jos:
int[] intregi;
String adrese[];
• Instanţierea:
Declararea unui vector nu implică şi alocarea memoriei necesare pentru reţinerea
elementelor. Operaţiunea de alocare a memoriei, numită şi instanţierea vectorului, se
realizează întotdeauna prin intermediul operatorului new. Instanţierea unui vector se va face
printr-o expresie de genul:
numeVector = new Tip[nrElemente];
unde nrElemente reprezintă numărul maxim de elemente pe care le poate avea vectorul. In
urma instanţierii vor fi alocaţi: nrElemente _ dimensiune(Tip) octeţi necesari memorării
elementelor din vector, unde prin dimensiune(Tip) am notat numărul de octeţi pe care se
reprezintă tipul respectiv.
v = new int[10];
//aloca spatiu pentru 10 intregi: 40 octeti
c = new char[10];
//aloca spatiu pentru 10 caractere: 20 octeti
Declararea şi instanţierea unui vector pot fi făcute simultan astfel:

Tip[] numeVector = new Tip[nrElemente];

• Iniţializarea (opţional):
După declararea unui vector, acesta poate fi iniţializat, adică elementele sale pot primi
nişte valori iniţiale, evident dacă este cazul pentru aşa ceva. În acest caz instanţierea nu mai
trebuie facută explicit, alocarea memoriei făcându-se automat în funcţie de numărul de
elemente cu care se iniţializează vectorul.

22
String saptamana[] = {"Luni", "Marti", "Miercuri","Joi", "Vineri", "Sambata", "Duminica"
};
int []factorial = {1, 1, 2, 6, 24, 120};

Primul indice al unui vector este 0, deci poziţiile unui vector cu n elemente vor fi cuprinse
între 0 şi n − 1.
In Java tablourile multidimensionale sunt de fapt vectori de vectori. De exemplu, crearea şi
instanţierea unei matrici vor fi realizate astfel:
Tip matrice[][] = new Tip[nrLinii][nrColoane];
matrice[i] este linia i a matricii şi reprezintă un vector cu nrColoane elemente iar
matrice[i][j] este elementul de pe linia i şi coloana j.
Cu ajutorul variabilei length se poate afla numărul de elemente al unui vector.
int []a = new int[5];
// a.length are valoarea 5
int m[][] = new int[5][10];
// m[0].length are valoarea 10
Pentru a înţelege modalitatea de folosire a lui length trebuie menţionat că fiecare vector este
de fapt o instanţă a unei clase iar length este o variabilă publică a acelei clase, în care este
reţinut numărul maxim de elemente al vectorului.
Copierea elementelor unui vector a într-un alt vector b se poate face, fie element cu element,
fie cu ajutorul metodei System.arraycopy, ca în exemplele de mai jos. După cum vom vedea,
o atribuire de genul b = a are altă semnificaţie decât copierea elementelor lui a în b şi nu
poate fi folosită în acest scop.
int a[] = {1, 2, 3, 4};
int b[] = new int[4];
// Varianta 1
for(int i=0; i<a.length; i++)
b[i] = a[i];
// Varianta 2
System.arraycopy(a, 0, b, 0, a.length);
// Nu are efectul dorit
b = a;
In Java s-a pus un accent deosebit pe implementarea unor structuri de date şi algoritmi care
să simplifice proceseul de crearea a unui algoritm, programatorul trebuind să se concentreze
pe aspectele specifice problemei abordate.
Clasa java.util.Arrays oferă diverse metode foarte utile în lucrul cu vectori cum ar fi:
• sort - sortează ascendent un vector, folosind un algoritm de tip Quick-Sort
performant, de complexitate O(n log(n)).

int v[]={3, 1, 4, 2};

java.util.Arrays.sort(v);
// Sorteaza vectorul v
// Acesta va deveni {1, 2, 3, 4}

• binarySearch - căutarea binară a unei anumite valori într-un vector sortat;

• equals - testarea egalităţii valorilor a doi vectori (au aceleaşi număr de elemente şi
pentru fiecare indice valorile corespunzătoare din cei doi vectori sunt egale)
• fill - atribuie fiecărui element din vector o valoare specificată.

23
Implementări ale vectorilor cu număr variabil de elemente sunt oferite de clase specializate
cum ar fi Vector sau ArrayList din pachetul java.util. Astfel de obiecte descriu vectori
eterogeni, şi au elemente de tipul Object.

Şiruri de caractere
In Java, un şir de caractere poate fi reprezentat printr-un vector format din elemente de tip
char, un obiect de tip String sau un obiect de tip StringBuffer.
Dacă un şir de caractere este constant (nu se doreşte schimbarea conţinutului său pe parcursul
execuţiei programului) atunci el va fi declarat de tipul String, altfel va fi declarat de tip
StringBuffer.
Diferenţa principală între aceste clase este că StringBuffer pune la dispoziţie metode pentru
modificarea conţinutului şirului, cum ar fi: append, insert, delete, reverse.
Uzual, cea mai folosită modalitate de a lucra cu şiruri este prin intermediul clasei String, care
are şi unele particularităţi faţă de restul claselor menite să simplifice cât mai mult folosirea
şirurilor de caractere.
Clasa StringBuffer va fi utilizată predominant în aplicaţii dedicate procesării textelor cum ar
fi editoarele de texte.
Iată câteva exemple echivalente de declarare a unui şir:
String s = "abc";
String s = new String("abc");
char data[] = {’a’, ’b’, ’c’};
String s = new String(data);
Observaţi prima variantă de declarare a şirului s din exemplul de mai sus care prezintă o
particularitate a clasei String faţă de restul claselor Java referitoare la instanţierea obiectelor
sale.
Concatenarea şirurilor de caractere se face prin intermediul operatorului + sau, în cazul
şirurilor de tip StringBuffer, folosind metoda append.
String s1 = "abc" + "xyz";
String s2 = "123";
String s3 = s1 + s2;
In Java, operatorul de concatenare + este extrem de flexibil, în sensul că permite
concatenarea şirurilor cu obiecte de orice tip care au o reprezentare de tip şir de caractere.
Mai jos, sunt câteva exemple:

System.out.print("Vectorul v are" + v.length + " elemente");

String x = "a" + 1 + "b"
Pentru a lămuri puţin lucrurile, ceea ce execută compilatorul atunci când întâlneşte o
secvenţă de genul String x = "a" + 1 + "b" este:
String x = new StringBuffer().append("a").append(1).
append("b").toString()
Trebuie ţinut cont de ordinea de efectuare a operaţiilor. Şirul s=1+2+"a"+1+2
va avea valoarea "3a12", primul + fiind operatorul matematic de adunare
iar al doilea +, cel de concatenare a şirurilor.

24
Folosirea argumentelor de la linia de comandă
O aplicaţie Java poate primi oricâte argumente 1 de la linia de comandă în momentul lansării
ei. Aceste argumente sunt utile pentru a permite utilizatorului să specifice diverse opţiuni
legate de funcţionarea aplicaţiei sau să furnizeze anumite date iniţiale programului.
Argumentele de la linia de comandă sunt introduse la lansarea unei aplicaţii, fiind specificate
după numele aplicaţiei şi separate prin spaţiu. De exemplu, să presupunem că aplicaţia
Sortare ordonează lexicografic (alfabetic) liniile unui fişier şi primeşte ca argument de intrare
numele fişierului pe care să îl sorteze. Pentru a ordona fişierul "nume.txt", aplicaţia va fi
lansată astfel:
java Sortare nume.txt
Aşadar, formatul general pentru lansarea unei aplicaţii care primeşte argument de la linia de
comandă este:
java NumeAplicatie [arg0 arg1 . . . argn]
În cazul în care sunt mai multe, argumentele trebuie separate prin spaţii iar dacă unul dintre
argumente conţine spaţii, atunci el trebuie pus între ghilimele. Evident, o aplicaţie poate să
nu primească nici un argument sau poate să ignore argumentele primite de la linia de
comandă.
In momentul lansării unei aplicaţii interpretorul parcurge linia de comandă cu care a fost
lansată aplicaţia şi, în cazul în care există, transmite programului argumentele specificate sub
forma unui vector de şiruri. Acesta este primit de aplicaţie ca parametru al metodei main().
Reamintim că formatul metodei main din clasa principală este:
public static void main (String args[])
Vectorul args primit ca parametru de metoda main() va conţine toate argumentele
transmise programului de la linia de comandă. În cazul apelului java Sortare nume.txt
vectorul args va conţine un singur element pe prima sa poziţie:

args[0]="nume.txt"
Vectorul args este instanţiat cu un număr de elemente egal cu numărul argumentelor primite
de la linia de comandă. Aşadar, pentru a afla numărul de argumente primite de program este
suficient să aflăm dimensiunea vectorului args prin intermediul atributului length:
public static void main (String args[]) {
int numarArgumente = args.length ;
}
În cazul în care aplicaţia presupune existenţa unor argumente de la linia de comandă, însă
acestea nu au fost transmise programului la lansarea sa, vor apărea excepţii (erori) de tipul
ArrayIndexOutOfBoundsException. Tratarea acestor excepţii este prezentată ulterior. Din
acest motiv, este necesar să testăm dacă programul a primit argumentele de la linia de
comandă necesare pentru funcţionarea sa şi, în caz contrar, să afişeze un mesaj de avertizare
sau să folosească nişte valori implicite, ca în exemplul de mai jos:

public class ExArg {

public static void main (String args[]) {
if (args.length == 0) {
System.out.println("Numar insuficient de argumente!");
System.exit(-1); //termina aplicatia
}
String nume = args[0]; //exista sigur

1
Programele care folosesc argumente de la linia de comandă nu sunt 100% pure Java, deoarece unele sisteme
de operare, cum ar fi Mac OS, nu au în mod normal linie de comandă.

25
 String prenume;
if (args.length >= 1)
prenume = args[1];
else
prenume = ""; //valoare implicita
System.out.println("Salut " + nume + " " + prenume);
}
}

Spre deosebire de limbajul C, vectorul primit de metoda main() nu conţine pe prima poziţie
numele aplicaţiei, întrucât în Java numele aplicaţiei este chiar numele clasei principale, adică
a clasei în care se gaseşte metoda main().
Să considerăm în continuare un exemplu simplu în care se doreşte afişarea pe ecran a
argumentelor primite de la linia de comandă:

public class Afisare {

public static void main (String[] args) {
for (int i = 0; i < args.length; i++)
System.out.println(args[i]);
}
}

Un apel de genul java Afisare Hello Java va produce următorul rezultat (aplicaţia a primit 2
argumente):

Hello
Java
Apelul java Afisare "Hello Java" va produce însă alt rezultat (aplicaţia a primit un singur
argument):
Hello Java
Argumentele de la linia de comandă sunt primite sub forma unui vector de şiruri (obiecte de
tip String). În cazul în care unele dintre acestea reprezintă valori numerice ele vor trebui
convertite din şiruri în numere. Acest lucru se realizează cu metode de tipul parseTipNumeric
aflate în clasa corespunzătoare tipului în care vrem să facem conversia: Integer, Float,
Double, etc.
Să considerăm, de exemplu, că aplicaţia Putere ridică un numar real la o putere întreagă,
argumentele fiind trimise de la linia de comandă sub forma:
java Putere "1.5" "2" //ridica 1.5 la puterea 2
Conversia celor două argumente în numere se va face astfel:
public class Putere {
public static void main(String args[]) {
double numar = Double.parseDouble(args[0]);
int putere = Integer.parseInt(args[1]);
System.out.println("Rezultat=" + Math.pow(numar, putere));
}
}
Metodele de tipul parseTipNumeric pot produce excepţii (erori) de tipul
NumberFormatException în cazul în care şirul primit ca parametru nu reprezintă un numar de
tipul respectiv. Tratarea acestor excepţii este prezentată ulterior.

26