PCLP2 - Indrumar de Laborator PDF

DominicMirceaKRISTLY AncaVULPE
LIMBAJULDEPROGRAMAREJAVA
ndrumardelaborator |Braov,2009

LimbajuldeprogramareJava
Cuprins

1.CreareairulareaprogramelorJavadinliniedecomand........................................................1
1.1.Creareacoduluisurs...........................................................................................................1
1.2.Compilareaprogramului......................................................................................................2
1.3.Lansareanexecuieaprogramului.....................................................................................4
2.CreareairulareaprogramelorJavacuajutorulplatformeiEclipse...........................................5
2.1.InterfaadelucruaplatformeiEclipse.................................................................................6
2.2.CreareaunuiproiectJava.....................................................................................................7
2.3.Creareapachetelor...............................................................................................................9
2.4.Creareaclaselor....................................................................................................................9
2.5.AplicaiaHelloWorld..........................................................................................................11
3.StructuraunuiprogramJava.....................................................................................................13
3.1.Definiiaclasei....................................................................................................................13
3.2.Definiiametodelor............................................................................................................13
3.3.Instruciuni.........................................................................................................................13
4.Tipuridedateprimitive.............................................................................................................15
4.1.Tipurintregi.......................................................................................................................15
4.2.Tipurireale.........................................................................................................................16
4.3.Tipulcaracter......................................................................................................................16
4.4.Tipullogic...........................................................................................................................17
4.5.Conversiintretipurilededateprimitive...........................................................................18
4.6.Variabile..............................................................................................................................18
4.7.Constante...........................................................................................................................19
4.8.Operatori............................................................................................................................19
4.9.Aplicaiecuvariabileioperatori......................................................................................20
5.CitireadelatastaturclasaScanner..................................................................................21
5.1.Introducereadatelordelatastaturiafiarealor...........................................................22
i
ndrumardelaborator
6.Structuridecontrol...................................................................................................................23
6.1.Instruciunidedecizie/selecie........................................................................................23
6.1.1.Instruciuneaif.........................................................................................................23
6.1.1.1.Clauzaelse......................................................................................................................24
6.1.1.2.Clauzaelse if...............................................................................................................24
6.1.1.3.Instruciuniifimbricate...................................................................................................25
6.1.1.4.Utilizareainstruciuniiif..................................................................................................26
6.1.2.Instruciuneaswitch................................................................................................27
6.1.2.1.Instruciuniswitchimbricate.........................................................................................28
6.2.Instruciuniiterative...........................................................................................................29
6.2.1.Instruciuneafor.......................................................................................................29
6.2.1.1.Cicluriforimbricate.........................................................................................................30
6.2.1.2.Utilizareainstruciuniifor...............................................................................................31
6.2.2.Instruciuneawhile..................................................................................................35
6.2.2.1.Utilizareainstruciuniiwhile...........................................................................................36
6.2.3.Instruciuneado..while.........................................................................................37
6.3.Instruciunidesalt.............................................................................................................38
6.3.1.Instruciuneabreak..................................................................................................38
6.3.2.Instruciuneacontinue...........................................................................................39
6.3.3.Instruciuneareturn................................................................................................39
6.4.Utilizareainstruciunilordo..while,switch,breakicontinue........................40
7.Tablouri.....................................................................................................................................43
7.1.TablouriunidimensionaleVectori...................................................................................43
7.1.1.Declarareavariabileitablou........................................................................................43
7.1.2.Instanierea.................................................................................................................43
7.1.3.Iniializarea..................................................................................................................44
7.2.TablourimultidimensionaleMatrice...............................................................................45
7.2.1.Creareaunuitabloumultidimensional.......................................................................45
7.2.2.Atribuireavalorilorctreelementelematricei...........................................................45
7.2.3.Proprietilength....................................................................................................46

ii
7.3.ClasaArrays....................................................................................................................46
7.3.1.Metodaequals()....................................................................................................46
7.3.2.Metodafill().........................................................................................................47
7.3.3.Metodasort().........................................................................................................48
7.3.4.MetodabinarySearch().....................................................................................48
7.3.5.Metodaarraycopy().............................................................................................49
7.4.Aplicaiecuvectori.............................................................................................................50
7.5.Aplicaiecuvectori:Loteria................................................................................................52
7.6.Aplicaiecuomatricebidimensional...............................................................................53
8.iruridecaractere.....................................................................................................................55
8.1.ClasaString....................................................................................................................55
8.2.ClasaStringBuffer......................................................................................................60
9.Claseiprogramareorientatobiect........................................................................................63
9.1.Termeniutilizainprogramareaorientatobiect............................................................63
9.2.Definiiauneiclase.............................................................................................................63
9.2.1.Modificatorideacces..................................................................................................64
9.2.2.Alimodificatori...........................................................................................................64
9.2.2.1.Modificatorulfinal........................................................................................................64
9.2.2.2.Modificatorulstatic......................................................................................................65
9.2.2.3.Modificatorulsynchronized.......................................................................................65
9.2.3.Proprieti...................................................................................................................65
9.2.4.Metode........................................................................................................................65
9.2.5.Constructori..................................................................................................................67
9.2.6.Declarareauneiinstaneauneiclase.........................................................................68
9.2.7.Accesullamembriiuneiclase.....................................................................................68
9.2.8.Suprancrcareametodelor.........................................................................................69
9.2.9.Cuvntulcheiethis..................................................................................................70
9.3.Creareaiutilizareclaselor(1)...........................................................................................72
9.4.Creareaiutilizareaclaselor(2).........................................................................................74
9.5.Claseinterne.......................................................................................................................75
iii
ndrumardelaborator
10.Motenirea..............................................................................................................................81
10.1.Accesullamembriiuneiclasemotenite.........................................................................82
10.2.Apelareaconstructorilor..................................................................................................83
10.2.1.Folosireacuvntuluicheiesuper...........................................................................84
10.2.1.1.Folosireacuvntuluicheiesuper.....................................................................................84
10.2.2.Motenireapemaimulteniveluri............................................................................85
10.2.2.1.Motenireapemaimulteniveluri...................................................................................85
10.2.3.Supradefinireametodelorfolosindmotenirea.......................................................87
10.2.3.1.Supradefinireametodelorfolosindmotenirea..............................................................88
10.2.4.Cuvntulcheiefinalimotenirea.......................................................................90
11.Tratareaexcepiilor.................................................................................................................91
11.1.Proceduridetratareaexcepiilor....................................................................................91
11.1.1.Blocuritryimbricate...............................................................................................97
11.2.Lucrulcuexcepiineinterceptate....................................................................................98
11.3.Metodecarenutrateazexcepiile.................................................................................99
11.4.Excepiiverificateineverificate...................................................................................100
11.5.TratareaexceptiilrfolosindsuperclasaException..................................................101
11.6.Exemple..........................................................................................................................102
11.6.1.ExcepiideI/O.........................................................................................................102
11.6.2.Excepii:Depireaindexuluiunuivector...............................................................103
11.6.3.Excepii:Vectorcudimensiunenegativ................................................................104
11.6.4.Excepii:NullPointerException..................................................................105
11.6.5.Excepii:ArrayIndexOutOfBoundsException..........................................106
12.Interfee................................................................................................................................107
13.Fluxurideintrare/ieiere(fiiere).......................................................................................112
13.1.Fiiereisistemedefiiere............................................................................................112
13.2.ClasaFILE.....................................................................................................................112
13.2.1.Afiarealisteidefiieredintrundirector...............................................................115
iv
13.3.Fluxuri.............................................................................................................................116
13.3.1.Scriereantrunfiier...............................................................................................117
13.3.2.Citireadintrunfiier.............................................................................................118
13.3.3.Adugareadatelorntrunfiier...........................................................................119
13.3.4.Citireaiscriereunuiobiectntrunfiier..........................................................120
14.Interfeegrafice....................................................................................................................124
14.1.Pachetuljavax.swing..............................................................................................125
14.2.Oaplicaiecuinterfagraficsimpl............................................................................125
14.3.Creareauneicasetededialog........................................................................................127
14.4.Concatenareaadouiruridecaractere.......................................................................128
ndrumardelaborator
vi
LABORATORUL1
1.CreareairulareaprogramelorJavadinliniedecomand
PaiicetrebuieurmaipentrucreareaunuiprogramJavasuntprezentaischematicnfigurade
maijos:

Fig.1.EtapelenecesarecreriiunuiprogramJava
1.1.Creareacoduluisurs
Codul surs este scris n limbajul Java i rezid ntrunul sau mai multe fiiere text avnd
extensia .java. Pentru scrierea programului se poate utiliza orice editor de texte. Dac se
lucreaz sub sistemul de operare Microsoft Windows, se poate utiliza, de exemplu, aplicaia
Notepad.DacselucreazsubUnix/Linuxprogramulvipoatefifolositpentruscriereacodului
surs.
Figura2prezintcodulsursalunuiprogramJavacareafieazpeecrantextulHelloWorld
dinJava!,aacumaratelnaplicaiaNotepad.

Fig.2.EditareaprogramelorJavacuajutorulaplicaieiNotepaddinWindows
Numele fiierului care conine codul surs al programului trebuie s aib numele
identiccunumeleclaseiceconinemetodamain().

ndrumardelaborator
1.2.Compilareaprogramului
Transformarea codului surs n codul de octei (byte code) neles de JVM (Java Virtual
Machine) se realizeaz prin compilarea programului. Pe sistemele Windows acest lucru este
realizatdeexecutabiluljavac.exe,cepoatefiapelatdintrofereastrsistem.
CompilatorulJavafacepartedinpachetulJDK(JavaDevelopmentKit)caretrebuiesfieinstalat
pecalculatorulpecaresedezvoltprogrameJava.Acestpachetpoatefidescrcat,gratuit,de
pe siteul companiei Sun microsystems. Programele prezentate n continuare au fost scrise i
testatefolosinduseversiunea6apachetuluiJDK.Acestpachetpoatefidescrcatdelaadresa:
http://java.sun.com/javase/downloads/index.jsp.
PentruacompilaprogramulHelloWorld,prezentatnfigura2,sedeschideofereastrsistem
(CommandPrompt),ncaresescrieurmtoareacomand,urmatdetastaCR(Enter):
javac HelloWorld.java
Dacprogramulafostcompilatcusucces,peecranaparedinnoucommandpromptul:
ndirectoruldelucruapareunnoufiier,numitHelloWorld.class,ceconinecoduldeoctei
alprogramului(aacumaratfigura3).
Fig.3.Codulsursifiierulobinutnurmacompilrii
Dacprogramulnuafostcompilatcusucces,nfereastrasistempotaparediferitemesajede
eroare,precum:
javac is not recognized as an internal or external command, operable program or

batchfile.
Cauzeposibile:
1. nuesteinstalatpachetulJDK.
o Soluie:instalareapachetuluiJDK;
2. esteinstalatpachetulJDK,darcaleadirectorului binnuafostinclusnvariabila
desistemPATH.
o Soluie: adugarea la variabila de sistem PATH a directorului bin. Acest
lucru se poate realiza, n Windows, din fereastra System properties,
accesibil prin clic dreapta pe iconia My Computer i selecia opiunii
Properties,saudinControlPanel(accesibildinStartMenuSettings)
n seciunea Advanced se efectueaz clic pe butonul Environment
Variables. n fereastra care se deschide, din lista System variables, se
selecteazvariabilaPATH,dupcareseapasbutonul Edit.
Lasfritulvaloriivariabileiseadaugcaracterul;,dacnuexist,dup
caresetrececaleacompletctredirectorulbinalpachetuluiJDK.

Fig.4.IncludereadirectoruluibinalpachetuluiJDKnvariabiladesistemPATH
ndrumardelaborator
2. ...shouldbedeclaredinafilenamed....
Cauzeposibile:
1. numelefiieruluinuestesalvatcuacelainumecucelalclaseiconinute.
o Soluie:redenumireafiieruluisauaclasei,astfelnctceledounumes
coincid.
javac:invalidflag:dacapareacestmesaj,urmatdeolistlungdecuvintecarencep
cu-cauzeleposibilesunt:
1. compilatorulnupoategsifiierulsursJava.Sevaafiadirectorulcurent.
2. scriereagreitanumeluifiieruluilacompilare.
3. omitereaextensieifiierului(.java).
Hellojava:6:;expected
Cndoeroareconinecuvntulexpectedurmatdeunfragmentdeprogramnseamn
cfragmentulrespectivconineoeroaredesintax.nacestexemplu,linia6estecea
careagenerateroarea.
1.3.Lansareanexecuieaprogramului
PentruaputealansanexecuieunprogramJava,calculatorulgazdtrebuiesaibinstalat
maina virtual Java (JVM). Aceasta este reprezentat de pachetul JRE (Java Runtime
Environment),careesteinclusinpachetulJDK.
LansareanexecuieaprogramuluiHelloWorldserealizeazprincomanda:
java HelloWorld
nfereastraCommandPromptaparemesajulHelloWorlddinJava!:
LalansareanexecuieaunuiprogramJavadinliniedecomandesteutilizatfiierulcu
extensia.class,daraceastextensienusemenioneaz,cinumainumelefiierului
(caretrebuiescoincidexactcunumeleclaseiceconinemetodamain()).

2.CreareairulareaprogramelorJavacuajutorulplatformeiEclipse
Eclipse este o platform multiscop pentru dezvoltarea de software, scris, n mare parte, n
limbajulJava,astfelputndrulapeoricesistemdeoperareactual.Oferunmediuintegratde
dezvoltare(IDEIntegratedDevelopmentEnvironment)pentrudiverselimbajedeprogramare
(Java, C/C++, PHP, Python, Perl, Cobol). Baza codului surs provine din platforma VisualAge
dezvoltatdeIBM,astfelseexplicsuportulprimitdinparteaacesteicompanii.
Platforma Eclipse se ncadreaz n categoria programelor gratuite i open source. Cea mai
recentversiune,EclipseGanymede,poatefidescrcatdepesiteuloficialwww.eclipse.org,
delaadresa:http://www.eclipse.org/downloads/,linkulEclipseIDEforJavaDevelopers.
PrintrefacilitileplatformeiEclipsemeritafimenionate:
creareaigestiuneadeproiecte;
debuging;
completareaautomatacodului(codecompletion);
automatizri pentru operaii des utilizate (redenumire, creare de setere i getere,
completareaautomataseciuniideimport).
Toate programele Java prezentate n continuare sunt dezvoltate folosind platforma Eclipse
GanymedeiJDK6iruleazpeJRE6.
VersiunileplatformeiEclipse,ncepndcuversiunea3.2,suntdenumitedupsateliiinaturalii
artificialiaiplaneteiJupiter(Callisto,Europa,Ganymede).Urmtoareaversiune,programatafi
lansatoficialn26iunie2009,sevanumiEclipseGalileo.
ndrumardelaborator
2.1.InterfaadelucruaplatformeiEclipse
La pornirea mediului Eclipse este cerut calea unui director care va fi spaiul de lucru al
platformei. Aici se vor salva proiectele i vor fi stocate datele necesare rulrii proiectelor n
lucru.

Fig.5.Seleciaspaiuluidelucru
Dac se utilizeaz acelai spaiu de lucru pentru toate proiectele, se poate bifa csua de
validare Use this as the default and do not ask again, pentru a elimina aceast ntrebare la
fiecarepornireaplatformei.
FerestrelevizibiledininterfaaEclipsesuntgrupatelogicnperspective.
O perspectiv indic numrul de ferestre vizibile, poziia lor i opiunile vizibile n aceste
ferestre,nfunciedelimbajulutilizatnproiectuldeschis.ncapturiledeecranprezentaten
acest ndrumar se va folosi perspectiva Java. Perspectiva curent se poate schimba de la
butoanelededicatesituatenparteadreaptsusaworkbenchuluiEclipse.
Figura6prezintferestrelevizibiledinperspectivaJavaisemnificaialor.

Fig.6.ComponenaperspectiveiJava
2.2.CreareaunuiproiectJava
DinmeniulFileNewsealegeopiuneaJavaProject.

Fig.7.a.CreareaunuiproiectJavanEclipse
nfereastracaresedeschidetrebuiespecificatnumeleproiectului.Esteindicatsfieselectat
opiuneaCreateseparatefoldersforsourcesandclassfilesdinseciuneaProjectlayout,pentru
a nu amesteca fiierele ce conin codul surs cu cele ce conin codul de octei, executabil.
PentruunproiectcompletnouestebinessealeagopiuneaCreatenewprojectinworkspace
a seciunii Contents. Apsarea butonului Next va determina accederea la mai multe opiuni,
cum ar fi importul unor librrii suplimentare, modificarea directoarelor unde vor fi salvate
surseleicoduldeocteialproiectului,etc.
Crearea i deschiderea n workbench a noului proiect se realizeaz prin apsarea butonului

Finish.
ndrumardelaborator

Fig.7.b.CreareaunuiproiectJavanEclipse

Fig.8.ProiectnoudeschisnworkbenchulplatformeiEclipse
2.3.Creareapachetelor
Clasele unui proiect Java sunt grupate, de regul, n pachete. Criteriile de grupare in de
funciilepecarelendeplinescaceleclasenproiect(lucrulcufiiere,accesullabazededate,
comunicaia prin reea, etc.). De asemenea, pachetele asigur i controlul numelor i al
vizibilitii.Fizic,unpachetesteundirectoralproiectului.
Accesul la clasele dintrun pachet se face prin utilizarea instruciunii import la nceputul
codului surs. Instruciunea import trebuie s conin numele pachetelor i ale claselor care
vorfifolositencodulsurs.
Crearea unui pachet n Eclipse se realizeaz prin clic dreapta pe numele proiectului, iar din
meniul care apare se alege NewPackage. n fereastra ce se deschide se specific numele
nouluipachetului,dupcareseapasbutonulFinish.

Fig.9.Crearepachetuluiprogramprincipal
Un pachet poate conine alte pachete, care, la rndul lor, pot conine alte pachete. n cazul
acestaseefectueazclicpenumelepachetuluincaresefaceadugarea,dupcareseparcurge
aceleaietapeprezentatemaisus.
2.4.Creareaclaselor
Clasele aparin pachetelor, prin urmare adugarea se va face prin clic dreapta pe numele
pachetului; se selecteaz NewClass. n fereastra care se deschide se completeaz numele
claseiiseselecteazopiunilepentruaceasta.
ndrumardelaborator

Fig.10.Creareauneiclase
Dac se dorete ca clasa creat sconin metoda main(), atunci se bifeaz opiunea public
staticvoidmain(String[]args)dinseciuneaWhichmethodstubswouldyouliketocreate?.Se
recomandcamodificatoruldeaccesalclaselorsfiecelpublic(seciuneaModifiers).
Se recomand respectarea urmtoarei convenii de notare: numele claselor ncep

ntotdeauna cu liter mare. Dac numele conine mai muli atomi lexicali (cuvinte),
fiecaredintreeincepculitermare.MaimultedetaliidespreconveniadenotareJava

aidentificatoriloribeneficiileadusederespectareaacesteiasegsesclaadresa:
http://en.wikipedia.org/wiki/Naming_conventions_(programming)#Java_language
DupapsareabutonuluiFinish,estedeschisautomatfiierulceconinedeclaraianoiiclase,
aacumsevedenfigura11.
10

Fig.11.ClasageneratautomatdeEclipse
2.5.AplicaiaHelloWorld
PentruafiareamesajuluiHelloWorlddinJava!sefoloseteinstruciunea:
System.out.println(Hello World din Java!);
Aceast instruciune trebuie plasat n interiorul metodei main() (care este echivalentul
programuluiprincipal:execuiaprogramuluincepecuaceastmetod).

Fig.12.AplicaiaHelloWorld
11
ndrumardelaborator
Deoarece instruciunea System.out.println() este foarte uzitat, editorul

platformeiEclipseoferoscurtturpentruscriereaei.Tastareatextuluisyso,urmat
de combinaia de taste CTRL+Space determin introducerea instruciunii
System.out.println().
Lansarea n execuie a programului se poate face din meniul RunRun, prin combinaia de
tasteCTRL+F11sauprinapsareabutonului dinbaradeinstrumente.
nainte de lansarea n execuie a unui program este recomandabil s salvai fiierele pe care
leaimodificat.Oricum,mediulEclipsevvacerepermisiuneadeasalvaacestefiierenainte
delansareanexecuie.
Rezultatul rulrii programului este afiat n fereastra Console, aflat n parte de jos a
workbenchului.

Fig.13.RezultatelerulriisuntafiatenfereastraConsole
12
3.StructuraunuiprogramJava
3.1.Definiiaclasei
3.2.Definiiametodelor
3.3.Instruciuni
13
ndrumardelaborator
14
LABORATORUL2
4.Tipuridedateprimitive
nlimbajulJavaexistdoucategoriidetipuridedate:
tipuriprimitive:tipurilenumerice,tipulcaracteritipullogic;
tipulreferin:reineoreferin(adres)ctreoinstanauneiclase(obiect).
LimbajulJavadefineteopttipuridedateprimitive.Acesteasepotclasifican:
tipurintregi: byte,short,intilong;
tipurireale:floatidouble;
tipulcaracter:char;
tipullogic:boolean.
4.1.Tipurintregi
Acestetipurisuntreprezentatenmemoriecanumerecusemn(reprezentarencomplement
fade2).LimbajulJavanuofertipurintregifrsemn.
Tipul Octeialocai Acoperirea

byte 1 128pnla127
short 2 32768pnla32767
int 4 2147483648pnla2147483647
long 8 9223327036854755808Lpnla922332703685475807L
Tipul byte este folosit, de obicei, pentru efectuarea unor operaii la nivel de bit sau la
prelucrarealanivelsczut(lowlevel)afluxurilor(streamfiiere,socketuri,etc.).
Tipulshortestedeseorifolositnlocultipuluiint,maialesdinmotivedeoptimizareautilizrii
memoriei.
Tipul int este cel mai des folosit, avnd avantajul c are o acoperire suficient de mare, iar
numrul de octei folosii pentru memorare este de dou ori mai mic dect tipul urmtor
(long).
Tipul long este mai rar folosit, nlocuind tipul int doar n cazul depirii acoperirii. Literalii
ntregidetiplongvoraveasufixulL;deexemplu:long l = 23568912457801112L.
n mod implicit, literalii ntregi sunt de tip int. Java suport utilizarea literalilor ntregi
reprezentaiinbazeledenumeraiehexazecimalioctal.
15
ndrumardelaborator
Utilizarealiteralilornbazeledenumeraiehexazecimalioctal
// numrul 10 scris n hexazecimal
int example_hexa = 0xA;
// numrul 8 scris n sistemul octal (folosirea acestei baze de numeraie

// nu este recomandat dat fiind forma confuz de declarare)
int example_octa = 010;
4.2.Tipurireale
Numerele reale sunt reprezentate n limbajul Java ca numere cu semn (reprezentare n

complementfade2,virgulmobilsimplsaudublprecizie).LimbajulJavanuofertipuri
realefrsemn.
Exist dou tipuri de numere reale reprezentate n virgul mobil: float (simpl precizie) i
double(dublprecizie).Numereleiraionale(cumarfisau2)sunttrunchiate,putnduse
lucradoarcuoaproximarealor.
Esterecomandatfolosireatipului floatnumaicndvitezalacaretrebuiesrulezeaplicaia
trebuiesfiefoartemare(saumemoriafolositdeaceastatrebuiesfiefoartemic).
nmodimplicitliteraliinumererealesuntreprezentaicavalori double.Literaliidetip float

poartsufixulF.Deexemplu:
// declarare de float
float example_float = 5.505F;
Caracteristicilecelordoutipuriesteprezentatntabelulurmtor:
Tipul Octeialocai Acoperirea

float 4 Aproximativ:3.40282347E+38F(67zecimale)
double 8 Aproximativ:1.79769313486231570E+308(1314zecimale)
4.3.Tipulcaracter
UtilizareacaracterelornJavasefacecuajutorultipuluichar.
TipulcaracterutilizeazpentrustocaredoiocteicereincodulUnicodealcaracterului.
16
Avantajul folosirii standardului Unicode este acela c acoperirea este de 65535 de caractere
(valorilelimitfiind \u0000i \uFFFF),fadecodulASCII(AmericanStandardCodesfor
InformationInterchange)carearedoar128decaracteresaudeASCIIextinscu256decaractere.
Dei se poate utiliza orice caracter, afiarea acestuia depinde de sistemul de operare
(caractereleUnicodenecunoscutesistemuluideoperarenuvorputeafiafiate).
Literaliidetipcaractersuntscriintreapostrofuriipotconinesecveneescape(secvenede
caracterecarencepcu\).
Declarareauneivariabiledetipcaractercuiniializare:
// variabila ch va contine caracterul avand codul 1111

// (codul este un numar hexazecimal)
char ch = '\u1111';
Urmtorultabelprezintcelemaifolositesecveneescape:
Secvenaescape ValoareaUnicode Denumire

\b \u0008 Backspace
\t \u0009 tab(TAB)
\n \u000A Linefeed(LF)
\r \u000D carriagereturn(CR)
\ \u0022 ghilimele
\ \u0027 apostrof
\\ \u005C backslash
4.4.Tipullogic
Tipullogicpermitememorareadoaradouvalori:adevrat(true)ifals(false).
Desemnareaacestuitip,nlimbajulJava,sefacecuajutorulcuvntuluicheieboolean.
Tipul boolean este folosit, n prinicpal, pentru evaluarea condiiilor logice. Introducerea sa a
eliminatneclaritiledinlimabjeleCiC++,undeevaluareacondiiilorsefceafolosindntregi.
Nusepoatefaceconversientretipurilebooleanicelentregi.
17
ndrumardelaborator
4.5.Conversiintretipurilededateprimitive
Tabelulurmtorsintetizeazconversiilepermisentretipurilededateprimitive:
byte short int long char float double

byte = * * * ! *
short ! = * * ! *
int ! ! = * ! *
long ! ! ! = !
char ! ! * * = *
float ! ! ! ! ! = *
double ! ! ! ! ! ! =
=acelaitip;
!conversianusepoateface;
*conversiasepoateface;
conversiasepoateface,darcupierderedeprecizie.
4.6.Variabile
Canoricelimbajdeprogramare,tipurilededatesuntutilizate,nprincipal,pentrudescrierea
variabileloristabilescfeluldatelorpecarelepotmemora,cantitateadememorienecesari
valorilecelepotfiasociate.
Maiconcret,ovariabilesteunspaiudememoriedestinatstocriiuneivalorintrunformat
corespunztortipuluideclaraticreiaiseataeazoetichetnumelevariabilei.Variabilele
ipotschimbavaloareaoricndpeparcursulprogramului.
Pentrudeclarareavariabilelor,limbajulJavautilizeazsintaxa:
Sintaxutilizat: id_tip id_var1[, id_var2 [, ...]];
Deexemplu,sepoatescrie:
int variabla;
boolean bool;
Semaipotfaceideclarrideforma:
int v1, v2;
daraceastmodalitatenuesteindicat.
Deseoriesterecomandatcavariabiladeclaratsconiniovaloareiniial:
int v1 = 10;
18
Astfel,sepoatespune,pescurt,cdefinireauneivariabilereprezintdeclarareaei,lacarese
adaugoperaiadeiniializare.
Declararea variabilelor se poate face oriunde pe parcursul programului. De asemenea,

variabilelesepotredeclara,curestriciacaredeclarareasnusefacnacelaibloccuprima
declaraie(decisnuseaflenacelaidomeniudedeclaraiescope).
Referitor la numele variabilelor se recomand denumirea lor n concordan cu semnificaia

datelorpecarelereprezint.Aceastmsurconferoclaritatesporitsurseiiminimizeaz
timpulnecesarefecturiiunorcorecturisaumodificri.
Deasemenea,numeleuneivariabilenupoatencepecuocifr;elepotncepecuoriceliter
saucaracterulunderscore(_).
4.7.Constante
Definirea constantelor n Java se face prefixnd definirea unei variabile cu final. Folosirea
constantelor este indicat cnd programatorul vrea ca valoarea unei variabile s nu poat fi
schimbat sau cnd se dorete stabilirea unor aliasuri. Imaginaiv c ntrun program este
necesar folosirea de mai multe ori a constantei matematice . Acest lucru se poate face
elegant fcnd o declarare de forma (exemplul este pur didactic; n practic, clasa
java.lang.Mathpoateoferivaloareaacesteiconstante):
final double PI = 3.14159;
4.8.Operatori
ntabelulurmtorsuntprezentaitoioperatorii,nordineaprecedeneilor.
Operatorul Tipuldeasociativitate
[] . () (apel de metod) delastngaladreapta
! ~ ++ -- +(unar) (unar) () (cast) new deladreaptalastnga
* / % delastngaladreapta
+ - delastngaladreapta
<< >> >>> delastngaladreapta
< <= > >= instanceof delastngaladreapta
== != delastngaladreapta
& delastngaladreapta
^ delastngaladreapta
| delastngaladreapta
&& delastngaladreapta
19
ndrumardelaborator
Operatorul Tipuldeasociativitate
|| delastngaladreapta
?: delastngaladreapta
= += -= *= /= %= &= |= ^= <<= >>= >>>= deladreaptalastnga
4.9.Aplicaiecuvariabileioperatori
VariabileOperatori.java
public class VariabileOperatori

{
public static void main(String[] args)
{
// declararea variabilelor
int a = 1;
int b = 1;
// operatori aritmetici
int c = a + b;
System.out.println("a+b=" + c);
c = a - b;
System.out.println("b-a=" + c);
System.out.println("b%a=" + b % a);
// incrementare decrementare
b = a++;/*
* i se transmite valoarea variabilei a(3) variabilei b(b=3)
* si apoi variabila a este incrementata(a=4)
*/
System.out.println("a=" + a + "\tb=" + b);
b = ++a;/*
* se incrementeza valoarea variabilei a(++a=5)si apoi i se
* transmite noua valoare variabilei b(b=5)
*/
b = a--;
b = --a;
// operatori relationali
if (a > b)
System.out.println("a este mai mare de decat b");
else
if (a < b)
System.out.println("a este mai mic decat b");
else
System.out.println("a si b sunt egale");
20
// operatorul ternar
double x = 1;
double y = 4;
char d = x < y ? 'x' : 'y';
System.out.println("dintre x si y mai mic este: " + d);
// Math
double z = Math.sqrt(y);
System.out.println("radical din x este:" + z);
double u = Math.pow(y, y);
System.out.println("x la puterea x este" + u);
// casts
double t = 9.9999;
int tt = (int) t;
System.out.println("t=" + t + "\ttt=" + tt);
double r = Math.round(t);
System.out.println("t rotunjit este " + r);
}
}
5.CitireadelatastaturclasaScanner
Permiteformatareaunordateprimitepeunfluxdeintrare.
Pentru a avea acces la clasa Scanner, aceasta trebuie importat n proiect folosind
instruciuneaimport:
import java.util.Scanner;
PentruacitidatedelatastaturtrebuieconstruitunobiectdetipScannercearecaargument
alconstructoruluifluxulSystem.in:
Scanner tastatura = new Scanner(System.in);
ncontinuaresepotutilizametodeledefinitenclasa Scannerpentrupreluareadatelordela
tastatur.Deexemplu:
datecevorfimemoratentrovariabilString
String nume = tastatura.nextLine();
datecevorfimemoratentrovariabildetipntreg

int ani = tastatura.nextInt();
Maimultedetalii:http://java.sun.com/javase/6/docs/api/java/util/Scanner.html.
21
ndrumardelaborator
5.1.Introducereadatelordelatastaturiafiarealor
IntrariIesiri.java
public class IntrariIesiri

{
{
/*
* pentru a citi date de la consola trebuie construit un obiect de
* tip Scanner
*/
System.out.print("Introduceti numele si prenumele: ");
/*
* utilizarea metodei nextLine(). nextLine() parcurge linia si
* returneaza intrarea care a fost parcursa
*/
String nume = tastatura.nextLine();
System.out.print("Cati ani aveti?");
// metoda next.Int() scaneaza intrarea intr-o variabila de tip int.
int ani = tastatura.nextInt();
System.out.println("Buna " + nume + " anul viitor veti avea " +
(ani + 1) + " ani.");
tastatura.nextLine();
System.out.print("str=");
String str = tastatura.nextLine();
}
}
22
LABORATORUL3
6.Structuridecontrol
6.1.Instruciunidedecizie/selecie
6.1.1.Instruciuneaif
Instruciunea if cere mainii virtuale Java s evalueze o expresie (condiie) la o valoare de
adevr. Dac expresia este adevrat, atunci sunt executate una sau mai multe instruciuni
aflatenbloculif.Dacexpresianuesteadevrat,instruciunilerespectivesuntomise.
Expresiaevaluatdintroinstruciuneifsenumeteexpresiecondiional.
Formatgeneral:
if (<conditie>)
[<instructiune_adevarat>];
Schemlogic:
Exemplu:
int m=3;
int n=4;
if(m>n)
System.out.println("m");
if(n>=m)
System.out.println("n");
23
ndrumardelaborator
6.1.1.1.Clauzaelse
Aceast clauz aparine instruciunii if i conine una sau mai multe instruciuni care sunt
executateatuncicndexpresiacondiionaldininstruciuneaifestefals.
Formatgeneral:
if (<conditie>)
[<instructiune_adevarat>];
[else
[<instructiune_fals>];]
Schemlogic:
Exemplu:
int m=3;
int n=4;
if(m>n)
else
6.1.1.2.Clauzaelse if
Formatgeneral:
if (<conditie_1>)
<instructiune_adevarat_1>;
else if (<conditie_2>)
<instructiune_adevarat_2>;
else
<instructiune_fals>;
24
Exemplu:
int m=3;
int n=4;
if(m>n)
else if(m==n)
System.out.println("m=n");
else
6.1.1.3.Instruciuniifimbricate
Existsituaiicndtrebuieluatonoudeciziedacprimacondiieesteadevrat.
Formatgeneral:
if (<conditie>)
if (<conditie_i>)
<instructiune_adevarat_i>;
else
<instructiune_fals_i>;
else
<instructiune_fals>;
Exemplu:
int m=3;
int n=4;
if(m>0 && n>0)
if(m==n)
System.out.println("m=n");
else
System.out.println("m!=n");
else
System.out.println("m si n sunt negative");
1.dupcondiienusepune;
2.dacblocurileifsauelseconinmaimultdeoinstruciune,atunciestenecesarca
instruciunile s fie ncadrate de acolade. Se recomand utilizarea acoladelor

ntotdeauna,indiferentdenumruldeinstruciunidinblocurileifielse.
25
ndrumardelaborator
6.1.1.4.Utilizareainstruciuniiif
EcuatiaDeGradulDoi.java
import java.util.*;
public class EcuatiaDeGradulDoi

{
{
/*
* construirea unui obiect de tip Scanner pentru citirea de la
* tastatura a coeficientilor ecuatiei de gradul 2
*/
Scanner valoare = new Scanner(System.in);
System.out.print("coeficientul lui x^2:");

// memorarea coeficientului luix^2 in variabila a
double a = valoare.nextDouble();
System.out.print("coeficientul lui x:");

// memorarea coeficientului luix in variabila b
double b = valoare.nextDouble();
System.out.print("termenul liber:");
// memorarea termenului liber in variabila c
double c = valoare.nextDouble();
if (a == 0 && b == 0 && c == 0)
{
System.out.println("Ecuatie nedeterminata !");
}
else
{
if (a == 0 && b == 0)
{
System.out.println("Ecuatie imposibila !");
}
else
{
if (a == 0)
{
System.out.println("Ecuatie de grad I");
System.out.println("Solutia este:" + -c / b);
}
else
{
double delta = b * b - 4 * a * c;
if (delta < 0)
{
System.out.println("Radacini complexe");
26
System.out.println("x1= " + (-b / (2 * a)) + "+ i*" +

(Math.sqrt(-delta) / (2 * a)));
System.out.println("x2= " + (-b / (2 * a)) + " -i*" +
(Math.sqrt(-delta) / (2 * a)));
// afisarea cu printf
// System.out.printf("x1=%.2f +i*%.2f", -b / (2 * a),
// Math.sqrt(-delta)/ (2 * a));
// System.out.printf("\nx2=%.2f -i*%.2f", -b / (2 * a),
// Math.sqrt(-delta)/ (2 * a));
}
else
{
if (delta == 0)
{
System.out.println("Radacini reale si egale:");
System.out.println("x1=x2=" + (-b / (2 * a)));
}
else
{
if (delta > 0)
{
System.out.println("Radacini reale si distincte:");
System.out.println("x1=" + ((-b + Math.sqrt(delta)) /
(2 * a)));
System.out.println("x2=" + ((-b - Math.sqrt(delta)) /
(2 * a)));
// afisarea cu printf
// System.out.printf("x1=", -b + Math.sqrt(delta) /
// (2 * a));
// System.out.printf("\nx2=", -b - Math.sqrt(delta) /
// (2 * a));
}
}
}
}
}
}
}
}
6.1.2.Instruciuneaswitch
Osoluiealternativlafolosireauneilungiseriideclauzeif...elseoreprezintfolosireaunei
instruciunidecontrolswitch,cunoscutisubnumeledeinstruciuneaswitch...case.
Instruciunea switch cere mainii Java s compare o expresie cu mai multe valori date,
coninute ntro etichet case. Dac valorile se potrivesc, se execut instruciunile din blocul
case.
27
ndrumardelaborator
Formatgeneral:
switch(<expresie>)
{
case(<valoare_1>): <instructiuni_1>;
[break;]
case(<valoare_2>): <instructiuni_2>;
[break;]
:
:
case(<valoare_n>): <instructiuni_n>;
[break;]
default: <instructiuni>;
[break;]
}
Exemplu:
int optiune=10;
switch (optiune)
{
case5: System.out.println("5");
break;
case10: System.out.println("10");
break;
default: System.out.println("Nici o potrivire");
}
1. n cazul n care n clauza case a crei constant se potrivete cu valoarea

expresieidin switchicomanda brakenuestefolosit,atunciseexecuti
instruciunile din clauzele case urmtoare, pn cnd ntlnete primul
breaksausetermininstruciunea switch.
2. Oclauz elseestefolositntroinstruciune ifpentruadefiniinstruciunile
executate atunci cnd condiia instruciunii nu este adevrat. Instruciunea
switchareofunciesimilar,numitclauzimplicit(defaultstatement).
3. Clauza implicit seamn cu o clauz case i este plasat ntotdeauna dup
ultima clauz case. Aceasta nu are ataat o constant i nici o instruciune
break, deoarece este ultima instruciune din blocul switch. Instruciunile
coninutenclauzaimplicitsuntexecutateatuncicndJavaajungelaaceasta.
6.1.2.1.Instruciuniswitchimbricate
O instruciune switch imbricat este o instruciune switch inserat ntro clauz case sau
defaultauneialteinstruciuniswitch.
28
6.2.Instruciuniiterative
AcesttipdeinstruciunicermainiivirtualeJavasexecuteunasaumaimulteinstruciuni,n
modrepetat,atttimpctestendeplinitocondiie.
nJavaexist3tipurideinstruciuniiterative:
for:instruciuneiterativcutestiniial,cunumrcunoscutdepai;
while:instruciuneiterativcutestiniial,cunumrnecunoscutdepai;
dowhile:instruciuneiterativcutestfinal,cunumrnecunoscutdepai.
6.2.1.Instruciuneafor
Instruciunea forseutilizeazatuncicndsecunoatesausepoateantecalculanumrulde
repetriainstruciunii/bloculuideinstruciuniicorpulinstruciuniifor.
Formatgeneral:
for ([<initializare>];[<conditie_continuare>];[<modificare_stare>])
[<instructiune>];
Schemlogic:
Exemplu:
for (int i=0 ; i<=2 ; i++)

{
System.out.println("i="+i);
}
29
ndrumardelaborator
Moduldelucru:
Ciclu Instruciune/operaie
i=0
1 test0<=2(A)
afiarei=0
i=1
2 test1<=2(A)
afiarei=1
i=2
3 test2<=2(A)
afiarei=2
i=3
4 test3<=2(F)setermininstruciuneafor
Expresiideiniializarealternative:
int i;
for(i=0;i<=2;i++)
{
}
int i=0;
for(;i<=2;i++)
{
}
1. Instruciunea forare,nparanteze,treiexpresiiseparateprincaracterul;
toate expresiile sunt opionale, dar caracterele punct i virgul i parantezele
suntobligatorii.
2. Dup parantezele instruciunii for nu se pune ;. Caracterul ; n aceast
poziie are semnificaia instruciunii vide, adic instruciunea care nu face
nimic.Practicaceastinstruciunevidsevaexecutanciclu.
6.2.1.1.Cicluriforimbricate
Se poate de vorbi despre cicluri for imbricate atunci cnd se plaseaz unul sau mai multe
cicluriforninteriorulaltuiciclufor.
Ciclulforimbricatestenumitcicluinterniesteplasatninteriorulunuicicluextern.
Defiecaredatcndseparcurgeciclulforextern,seexecut,complet,iciclulforintern.
30
Exemplu:
for(int i=0;i<3;i++)
{
System.out.print("\ni="+i);
for(int j=0;j<=2;j++)
{
System.out.print("\tj="+j);
}
}
Rezultatulexecuiei:
i=0 j=0 j=1 j=2

i=1 j=0 j=1 j=2
i=2 j=0 j=1 j=2
6.2.1.2.Utilizareainstruciuniifor
ExempluFor.java
public class ExempluFor

{
{
System.out.print("Introduceti un numar:");
/*
* memorarea numarului introdus de la tastatura intr-o variabila "a"
*/
int a = tastatura.nextInt();
System.out.print("Introduceti un divizor: ");

int b = tastatura.nextInt();
// declararea unei variabile de tip primitiv (int)

int x;
{
int suma = 0;
for (x = 1; x <= a; x++)
suma += x; // acelasi lucru cu: suma=suma+x;
System.out.println("Suma celor " + a + " numere este " + suma);
}
{
int suma = 0;
for (x = 1; x <= a; x += 2)
suma += x;
31
ndrumardelaborator
System.out.println("Suma numerelor impare pana la " + a +

" este " + suma);
}
{
int suma = 0;
for (x = 0; x <= a; x += 2)
suma += x;
System.out.println("Suma numerelor pare pana la " + a +
" este " + suma);
}
// numere prime varianta 1

{
System.out.print("Numerele prime de la 1 la " + a +
" (v1) sunt:");
for (int i = 1; i <= a; i++)

{
boolean numarPrim = true;
/*
* realizarea unui ciclu for imbricat pentru a verifica
* daca este indeplinita conditia ca numarul prim
* sa fie divizibil doar cu 1 si cu el insusi
*/
for (int j = 2; j < i; j++)

{
if (i % j == 0)
{
numarPrim = false;
break; // fortarea iesirii din instructiunea for
}
}
// afisarea numarului daca este prim

if (numarPrim)
{
System.out.print("\t" + i);
}
}
}
// numere prime varianta 2

{
System.out.print("\nNumerele prime de la 1 la " + a +
" (v2) sunt:");
for (int i = 1; i <= a; i++)

{
32
for (int j = 2; j <= i/2; j++)

{
if (i % j == 0)
{
numarPrim = false;
break;
}
}
if (numarPrim)
{
}
}
}
// varianta 3
{
System.out.print("\nNumerele prime de la 1 la " + a +
" (v3)sunt:");
for (int i = 1; i <= a; i++)

{
for (int j = 2; j <= Math.sqrt((double) i); j++)
{
if (i % j == 0)
{
numarPrim = false;
break;
}
}
if (numarPrim)
{
}
}
}
{
System.out.print("\nNumerele de la 1 la " + a +
" divizibile cu " + b + " sunt: ");
for (int i = 1; i <= a; i++)
{
if (i % b == 0)
}
}
}
}
33
ndrumardelaborator
34
LABORATORUL4
6.2.2.Instruciuneawhile
Ciclul while cere mainii virtuale Java s execute una sau mai multe instruciuni, din corpul
ciclului,atttimpctoexpresiecondiionalesteadevrat.
Formatgeneral:
while (<conditie_continuare>)
[<instructiune>];
Schemlogic:
Exemplu:
int i=0;
while (i<=2)
{
i++;
}
Atuncicndntlneteunciclu whilenprogram,Javaevalueazexpresiacondiional.Dac
aceast condiie este evaluat ca fals, Java sare peste corpul instruciunii while i continu
execuiacuprimainstruciunecareaparenprogram,dupcorpulinstruciuniiwhile.
Dac una din instruciunile aflate n corpul instruciunii while este break, Java ntrerupe
execuiainstruciuniiwhileicontinucuprimainstruciunededupwhile.
35
ndrumardelaborator
6.2.2.1.Utilizareainstruciuniiwhile
ExempluWhile.java
public class ExempluWhile

{
{
Scanner a = new Scanner(System.in);
System.out.print("Cati bani doresti sa retragi? ");

// memorarea valorii creditului in variabila retragere
double retragere = a.nextDouble();
System.out.print("Cu cati bani vrei sa contribui in fiecare an? ");

// memorarea valorii ratei anuale in variabila rata
double rata = a.nextDouble();
System.out.print("Introduceti dobanda %: ");

/*
* declararea unei variabile (dobanda)pentru memorarea ratei
* dobanzii(in procente)
*/
double dobanda = a.nextDouble();
/*
* declararea unei variabile(returnat)pentru memorarea valorii
* returnate in fiecare an
*/
double returnat = 0;
/*
* declararea unei variabile(luni)pentru memorarea timpului scurs
* de la acordarea creditului pana la lichidarea creditului
*/
double luni = 0;
while (returnat < retragere)
{
/*
* declararea unei variabile pentru memorarea valorii dobanzii,
* valoare ce este calculata in fiecare an in functie de
* suma ramasa de rambursat
*/
double dobandaP = ((retragere - returnat) * dobanda) / 100;
// valoarea rambursata in fiecare an

double x = rata - dobandaP;
36
if ((retragere - returnat) < (x))

{
// calculul ultimelor luni cand suma de rambursat impreuna cu
// dobanda este mai mica decat rata anuala
luni += (((retragere - returnat) + dobandaP) * 12) / x;
}
else
{
luni += 12;
}
returnat += x;
int l = (int) luni % 12;

System.out.println("Poti plati in " + (int) luni / 12 + " ani si " +
l + " luni.");
}
}
6.2.3.Instruciuneado..while
Ciclul do..while cere mainii virtuale Java s execute una sau mai multe instruciuni, din
corpulciclului,atttimpctoexpresiecondiionalesteadevrat.
Formatgeneral:
do {
[<secventa_de_instructiuni>;]
} while (<conditie_de_continuare>);
Schemlogic:
Ciclul do..while este format din ase componente: cuvntul cheie do, corpul ciclului
do..while, definit deacolade dedeschiderei nchidere, una sau mai multe instruciuni din
37
ndrumardelaborator
corpul ciclului, cuvntul cheie while, expresia condiional, ncadrat de paranteze, i un

caracterpunctivirgul.
Exemplu:
int i=0;
do {
i++;
} while(i<=2);
Instruciuniledintrunciclu do..while(aceastafiindoinstruciunedeciclarecutest
final)suntexecutatecelpuinodat,chiardacexpresiacondiionalestefals.

6.3.Instruciunidesalt
Acesteinstruciunitransfercontrolulexecuieintroaltparteaprogramului.
6.3.1.Instruciuneabreak
AceastinstruciuneceremainiivirtualeJavasiasdintrunblocdecoddefinitdeacoladede
deschidereinchidere.
Exemplu:
for(int i=2;i<=5;i++)
{
if(i==4)
break;
}
Rezultatulrulrii:
i=2
i=3
n momentul n care condiia din if este ndeplinit (i=4), se execut instruciunea break i
chiardaccondiiadinfor(i<=5)esteadevratciclulsencheie.
38
6.3.2.Instruciuneacontinue
Instruciunea continue este folosit n corpul unui ciclu pentru a cere mainii virtuale Java s
renunelaexecuiaiteraieicurenteistreaclaurmtoarea.
Exemplu:
for(int i=2;i<=5;i++)
{
System.out.println("Inainte de continue i="+i);
if(i==4)
continue;
System.out.println("Dupa continue i="+i);

}
Rezultatulrulrii:
Inainte de continue i=2

Dupa continue i=2
Dupa continue i=3
Dupa continue i=5
nmomentulncarecondiiadin ifestendeplinit(i=4)seexecutinstruciunea continue.

Dupacestapelseignortoateinstruciunileaflatedupinstruciunea continueisetrecela
urmtoareaiteraie.
6.3.3.Instruciuneareturn
Instruciunea return este folosit n metode pentru a transfera napoi controlul execuiei la
instruciuneacareaapelatmetoda.Instruciuneapoatereturnaovaloare,daracestlucrunu
esteobligatoriu.
39
ndrumardelaborator
6.4.Utilizareainstruciunilordo..while,switch,breakicontinue
ExDoWhileSwitch.java
public class ExDoWhileSwitch

{
{
Scanner n = new Scanner(System.in);
int a, b, c;
do {
System.out.print("Introdu un numar natural: ");
a = n.nextInt();
System.out.print("Introdu un divizor: ");
b = n.nextInt();
} while (a <= 0 && b <= 0);
do {
// afisarea meniului
System.out.println("\nMENIU:");
System.out.println("1.Afisarea sumei primelor " + a
+ "numere naturale");
System.out.println("2.Afisarea sumei numerelor impare de la 1 la"
+ a);
System.out.println("3.Afisarea sumei numerelor pare de la 1 la"
+ a);
System.out.println("4.Afisarea primelor numere prime de la 1 la"
+ a);
System.out.println("5.Afisarea numerelor de la 1 la " + a
+ "divizibile cu" + b);
System.out.println("6.IESIRE DIN PROGRAM");
// citirea optiunii utilizatorului

System.out.print("Introduceti optiune dvs.:");
c = n.nextInt();
switch (c)
{
case 1:
int suma = 0;
for (int x = 1; x <= a; x++)
suma += x;
System.out.println("Suma primelor " + a +
" numere naturale este: " + suma);
break;
case 2:
40
int sumaimp = 0;
for (int x = 1; x <= a; x += 2)
sumaimp += x;
System.out.println("Suma numerelor impare de la 1 la " + a +
" este: " + sumaimp);
break;
case 3:
int sumap = 0;
for (int x = 0; x <= a; x += 2)
sumap += x;
System.out.println("Suma numerelor pare de la 1 la " + a +
" este: " + sumap);
break;
case 4:
System.out.print("Numerele prime de la 1 la " + a + " sunt: ");
for (int i = 1; i <= a; i++)
{
for (int j = 2; j < i/2; j++)
{
if (i % j == 0)
{
numarPrim = false;
break;
}
}
if (numarPrim)
{
}
}
break;
case 5:
System.out.print("Numerele de la 1 la " + a +
" divizibile cu " + b + " sunt:\n");
for (int i = 1; i <= a; i++)
if (i % b == 0)
{
System.out.print("\t");
System.out.print(i);
}
break;
case 6:
System.out.println("Sfarsit de program");
break;
default:
41
ndrumardelaborator
System.out.println("Optiunea dumneavoastra nu este definita.");

}
} while (c != 6);
}
}
42
LABORATORUL5
7.Tablouri
Rezervareamemorieipentrustocareauneidateesteooperaiefoartesimpl:sefoloseteun
tipdedateiunnumepentruadeclaraovariabil.
Spresupunemctrebuierezervatmemoriepentruastoca100deelementedeunanumittip.
Laprimavederenuparecomplicat:trebuiedeclarate100devariabile.Acestlucrupresupune
gsirea a 100 de nume sugestive i unice, o sarcin nu tocmai uoar, iar managementul
variabilelor ar fi un comar. Acest lucru poate fi simplificat prin declararea unui tablou. Un
tablouarenevoiedeunsingurnumeunicisugestiv,carepoatefiapoifolositpentrureferirea
tuturorcelor100deelementededatesauorictesuntnecesarenprogram.
Un tablou este o colecie de variabile de acelai tip de date, creia i este asociat un nume.
Fiecare variabil din colecie este numit element al tabloului. Un element al tabloului este
identificatprintrocombinaientrenumeletablouluiiunindexunic.
Unindexesteunntregcuprinsntrezeroinumrulmaximdeelementealetabloului,minus
unu.Indexulestespecificatntreparantezedrepte,ndreaptanumeluivariabileitablou.
7.1.TablouriunidimensionaleVectori
7.1.1.Declarareavariabileitablou
Declarareauneivariabiledetiptablouunidimensionalsefaceutilizndsintaxa:
Sintaxutilizat: <tip_elemente> <identificator_tablou>[];
sau
<tip_elemente>[] <identificator_tablou>;
unde:
<tip_elemente>reprezinttipuldedatealelementelorvectorului
<identificator_tablou>estenumelevectorului,caretrebuiesfieunicisugestiv
[] specificfaptulcestedeclaratunvector,inuosimplvariabil
7.1.2.Instanierea
Instanierea definete procesul de creare a unui obiect, respectiv alocarea memoriei pentru
acestaiefectuareatuturoriniializrilornecesare.
43
ndrumardelaborator
Tipul tablou este un tip de date referin, prin urmare trebuie utilizat instanierea
pentrucreareaunuiobiectdetiptablou.

Memoriaestealocatdinamic,printrunprocesntreietape:
1. Declarareauneivariabilereferin;
2. Alocareamemoriei;
3. Asocierealocaieidememorierezervatcuvariabilareferin.
Declarareaiinstaniereaunuivectorpotfifcutesimultan:
int[] note = new int[6];
Operatorul newceremainiivirtualeJavasrezervememoriepentrustocareaa6valorintregi
prinnew int[6].
Operatorul new returneaz adresa primului element. Celelalte elemente sunt dispuse, n
memorie,unalngcealalt,secvenial,dupprimulelement.
Adresareturnatestememoratnvariabilareferin.
1.Cndsedeclaruntablousespecificntotdeaunanumruldeelemente.
2.Primulindexaltablouluieste0,inu1,iarultimulelementaltablouluiareindexul
numruldeelemente1,inunumruldeelemente.

7.1.3.Iniializarea
Reprezintprocesulprincareuneivariabileisedovaloare.
Lainiializareaunuivectorvalorileiniialetrebuieinclusentreacoladeiseparateprinvirgule.
int note[]={10,9,10,8,9};
Nu este nevoie s se specifice explicit dimensiunea tabloului. Numrul de valori iniiale este
folositpentruastabilidimensiuneaacestuia.
Nu se folosete operatorul new pentru declararea unui tablou dac acesta se

iniializeaz.Javaalocdinamicmemoriesuficientpentrutablou,folosindnumrulde
valoridininiializarepentruaideterminadimensiunea.

44
7.2.TablourimultidimensionaleMatrice
Tablourilepotaveamaimultedimensiuni.Acesteasuntnumitetablourimultidimensionalesau
matrice.
7.2.1.Creareaunuitabloumultidimensional
Declarareauneimatricesepoatefacefolosindoperatorul new,ntrunmodasemntorcucel
folositpentrutablouriunidimensionale.Exempluurmtorilustreazaceasttehnic.
int note[][] = new int [3][2];
Fiecareperechedeparantezedreptedindeclarareauneimatricereprezintodimensiune.
Indexul din stnga

Fig.14.Elementeletablourilormultidimensionale
7.2.2.Atribuireavalorilorctreelementelematricei
Unelementalunuitablouestefolositntroexpresielafelcaiovariabil.Singuradiferen
dintreovariabiliunelementalunuitablouestefaptulcpentruelementultablouluitrebuie
specificatattnumeletablouluictiindexulelementului.
Sepoateatribuiovaloareunuielementaltablouluifolosindoperatoruldeatribuire.
note[0]=9;
Valoarea atribuit unui element al unui tablou poate fi folosit ntro expresie la fel ca i
valoareauneivariabile.
note[1]=note[0];
Acelaiformatestefolositipentrutablourilecefolosescdousaumaimultedimensiuni:
note[1][1]=note[0][1];
45
ndrumardelaborator
Un tablou multidimensional este, de fapt, un tablou de tablouri. n exemplu anterior, tabloul

noteesteunvectorde3elementedetipvectorde2elemente.
7.2.3.Proprietilength
Tipul tablou, fiind un tip referin, are proprieti ce pot fi utilizate de programator. Cea mai
utilesteproprietatealength,carereturneaznumruldeelementealtabloului.
Exemplu:
int note[]={10,9,10,8,9};
System.out.print("Notele sunt:");
for(int i=0;i<note.length;i++)
{
System.out.print(" " + note[i]);
}
7.3.ClasaArrays
Clasa Arrays definete un numr mare de metode utile n lucrul cu tablouri. Cele mai des
utilizate sunt: equals(), fill(), sort(), binarySearch(). Toate aceste metode sunt
statice,decinudepinddeinstane,putndusefolosiprinintermediulnumeluiclasei(Arrays).
Clasa Arrays se afl n pachetul java.util, deci pentru a o putea folosi trebuie importat
acestpachet.
7.3.1.Metodaequals()
Aceastmetodestefolositpentruacomparaelementeleunuitablou.
Doutablourisunttransmisecaparametriimetodei equals(),carestabiletedactablourile
suntidentice(elementeleconinutesuntegale).ncazafirmativ,metodaequals()returneaz
valoareabooleanatrue,altfelreturneazvaloareabooleanafalse.
ExempluEquals.java
import java.util.*;
public class ExempluEquals

{
{
int note1[] = new int[3];
note1[0] = 10;
note1[1] = 9;
note1[2] = 8;
46

note2[0] = 10;
note2[1] = 9;
note2[2] = 8;
if (Arrays.equals(note1, note2))
System.out.println("Notele sunt egale!");
else
System.out.println("Notele nu sunt egale!");
}
}
Metodaequals()esteapelatprinreferireaclaseiArrays.Numeleclaseitrebuiesprecead
numele metodei folosit n program, iar numele clasei i numele metodei trebuie s fie
separateprinoperatorulpunct.
7.3.2.Metodafill()
Sefolosetecndtrebuieatribuitevaloriiniialeelementelorunuitablou.
nexemplulurmtorsuntprezentatedouversiunialemetodei:
Primaversiunearenevoiededouargumente:numeletablouluii valoareacarevafi
atribuit elementelor matricei. Este important ca tipul de date al acestei valori s fie
compatibilcucelalelementelortabloului.
A doua versiune are nevoie de patru argumente: numele tabloului, indexul primului
elementacruivaloarevafischimbat,indexulultimuluielementalcruivaloarevafi
schimbativaloareacevafiatribuitelementelornintervalulspecificat.
ExempluFill.java
import java.util.*;
public class ExempluFill

{
{
// se utilizeaza un vector de 2000 de elemente de tip int
int note[] = new int[2000];
Arrays.fill(note, 0);
for (int i = 0; i < note.length; i++)

System.out.println("" + note[i]);
Arrays.fill(note, 100, 1500, 3);

47
ndrumardelaborator

System.out.println(i + "" + note[i]);
}
}
7.3.3.Metodasort()
Sorteaz cresctor elementele unui tablou folosind algoritmul QuickSort. Dac elementele
tablouluisunttipurireferin(clase),acesteatrebuiesimplementezeinterfaaComparable.
Metodaprimeteunsingurargumentvariabilatablou.
ExempluSort.java
import java.util.*;
public class ExempluSort

{
{
int note[] = { 5, 2, 4, 1, 7, 3, 5, 7, 0 };
Arrays.sort(note);

System.out.println(note[i]);
}
}
7.3.4.MetodabinarySearch()
Aceastmetodcautunanumitelementntruntablou.
Pentruafolosiaceastmetodtabloultrebuiesfiesortatnaintedeasefacecutarea.
Metoda binarySearch() are nevoie de dou argumente: numele tabloului i criteriul de

cutare.Criteriuldecutaretrebuiesfiecompatibilcutipuldedatealelementelortabloului.
Metodareturneazovaloarentreag.Acestapoatefiunnumrpozitivsauunnumrnegativ.
Un numr pozitiv reprezint indexul elementului care conine valoarea cutat. Un numr
negativnseamncvaloareacutatnuafostgsitntablou.
48
ExempluBinarySearch.java
import java.util.*;
public class ExempluBinarySearch

{
{
int note[] = { 5, 2, 4, 1, 7, 3, 5, 7, 0 };
int index;
Arrays.sort(note);
index = Arrays.binarySearch(note, 2);

System.out.println(index);
index = Arrays.binarySearch(note, 99);

System.out.println(index);
}
}
Rezultatulrulrii:
2
-10
7.3.5.Metodaarraycopy()
Metoda arraycopy() se utilizeaz pentru a copia elementele unui tablou n alt tablou sau
pentruacopiaopartedinelementeleuneitablounalttablou.
AceastmetodstaticfacepartedinclasaSystemiare5argumente:numeletablouluisurs,
indexul elementului din tabloul surs de unde ncepe copierea, numele tabloului destinaie,
indexulelementuluidintablouldestinaiedeundencepecopiereainumruldeelementece
vorficopiate.
ExempluArrayCopy.java
import java.util.*;
public class ExempluArrayCopy

{
{
int note1[] = { 5, 2, 4, 1, 7, 3, 5, 7, 0 };
Arrays.fill(note2, 0);
49
ndrumardelaborator
System.arraycopy(note1, 3, note2, 1, 4);
for (int i = 0; i < note2.length; i++)

System.out.print("::" + note2[i]);
}
}
Rezultatulrulrii:
::0::1::7::3::5::0::0::0::0
7.4.Aplicaiecuvectori
Vectori.java
import java.util.*;
public class Vectori

{
{
int[] nota = new int[4];
System.out.println("Introduceti notele de la fiecare laborator: ");

citire(nota);
afisare(nota);
System.out.println("Media este: " + media(nota));
// schimbarea valorilor unor elemente

Arrays.fill(nota, 0, 2, 9);
afisare(nota);
System.out.println("Laboratorul 1 si 2 au acum valoarile: " +

nota[0] + " si " + nota[1]);
System.out.println("Ordonare notelor");
// argumentul este de tip referinta iar metoda ii va modifica starea

Arrays.sort(nota);
afisare(nota);
// copierea vectorilor
int notaCopie1[] = nota;
System.out.println("Afisarea primei copii");

afisare(notaCopie1);
50
int notaCopie2[] = new int[4];

System.arraycopy(nota, 0, notaCopie2, 0, nota.length);
System.out.println("Afisarea copiei numarul 2");

afisare(notaCopie2);
int[] mat1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int[] mat2 = { 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
/*
* se copieaza mat1 incepand cu indexul 1(2 elemente) in mat2
* la pozitia index5 a tabloului
* ( arraycopy(from,formindex,to,to index,count) )
*/
System.arraycopy(mat1, 1, mat2, 5, 2);
System.out.println("Noile elementele ale matricii mat2 sunt:");
afisare(mat2);
}
static void citire(int nota[])

{
// atribuirea valorilor catre elementele tabloului
Scanner valoare = new Scanner(System.in);
for (int i = 0; i < nota.length; i++)
{
System.out.print("Laboratorul " + (i + 1) + ": ");
nota[i] = valoare.nextInt();
}
}
static void afisare(int[] nota)

{
System.out.println("Laborator " + (i + 1) + ": " + nota[i]);
}
static double media(int nota[])

{
double media = 0;
media += nota[i];
return media / nota.length;

}
static void afisareCopie1(int[] nota)

{
System.out.println(nota[i]);
}
}
51
ndrumardelaborator
7.5.Aplicaiecuvectori:Loteria
Loteria.java
import java.util.*;
public class Loteria

{
{
Scanner in = new Scanner(System.in);
System.out.print("Cate bile doresti sa extragi? ");

int k = in.nextInt();
System.out.print("Care este nuamarul maxim de bile? ");
int n = in.nextInt();
// construirea unei matrici numarul total de bile

int[] bile = new int[n];// maxim de bile
for (int i = 0; i < bile.length; i++)
bile[i] = i + 1;
// construirea unei matrici pentru bilele extrase

int[] extras = new int[k]; // bile extrase
for (int i = 0; i < extras.length; i++)
{
// realizarea unei extrageri in mod aleatoru intre 0 si n-1
int r = (int) (Math.random() * n);
// extragerea unei bile
extras[i] = bile[r];
// mutarea ultimului element in locatia aleatoare
bile[r] = bile[n - 1];
n--;
}
// sortarea bilelor extrase in ordine crescatoare

Arrays.sort(extras);
System.out.println("Cea mai buna combinatie: ");
// afisarea bilelor extrase
// for(variabila:colectie)->afiseaza elementele colectiei
for (int r : extras)

System.out.println(r);
// sau
// for(int r=0;r<extras.length;r++)
// System.out.println(extras[r]);
}
}
52
7.6.Aplicaiecuomatricebidimensional
MatriceBi.java
public class MatriceBi

{
{
final int capTabel = 10;
final int coloane = 6;
final int linii = 10;
// setarea ratei dobanzii 10 . . . 15%(dobandap=dobanda procent)

double[] dobandap = new double[coloane];
for (int j = 0; j < dobandap.length; j++)
{
dobandap[j] = (capTabel + j) / 100.0;
}
// crearea unei matrici bidimensionale pentru afisarea valorilor

// depozitului pe 10 ani(coloane)cu diferite dobanzi(10-15%)
// (6 coloane)
double[][] balanta = new double[linii][coloane];
// setarea valorii initiale cu 10000

for (int j = 0; j < balanta[0].length; j++)
{
balanta[0][j] = 10000;
}
// calcularea ratei pentru anii viitori

for (int i = 1; i < balanta.length; i++)
{
for (int j = 0; j < balanta[i].length; j++)
{
// valoarea anului trecut pentru calculul dobanzii
double oldBalance = balanta[i - 1][j];
// calcularea valorii dobanzii
double dobanda = oldBalance * dobandap[j];
// calcularea valorii corespunzatoare anului si dobanzii
balanta[i][j] = oldBalance + dobanda;
}
}
// afisarea randului cu valorile procentelor

for (int j = 0; j < dobandap.length; j++)
{
System.out.printf("%9.0f%%", 100 * dobandap[j]);
}
System.out.println(); // trecere la randul urmator
53
ndrumardelaborator
// afisarea valorilor in tabel

for (double[] row : balanta)
{
// afisarea fiecarui rand din tabel
for (double b : row)
System.out.printf("%10.2f", b);
System.out.println();
}
}
}
54
LABORATORUL6
8.iruridecaractere
iruriledecaracterepotfireprezentatedetipurileStringiStringBuffer.
Dac se dorete ca un ir de caractere s rmn constant, atunci se folosete tipul String.

Dacsedoretemodificareairului,atuncisevautilizatipul StringBuffer,deoareceaceast
clas pune la dispoziie metode de prelucrare a irului ncapsulat (append(), insert(),
delete(),reverse()).
Concatenarea irurilor de caractere se realizeaz prin intermediul operatorului +, n cazul

irurilor de tip String, i prin intermediul metodei append() n cazul irurilor de tip
StringBuffer.
8.1.ClasaString
ListatuturorproprietilorimetodeloraleclaseiStringsegsetelaadresa:
http://java.sun.com/javase/6/docs/api/java/lang/String.html.
ExemplededeclarareiinstaniereaobiectelordetipString
String sir1 = "sir";
String sir2 = new String("sir");
char sir[] = {'s','i','r'};

String sir3 = new String(sir);
System.out.println(sir1);
ExempluString.java
public class ExempluString

{
{
// declararea a patru siruri de caractere cu initializare
String s1 = "Happy girl!";
String s2 = "Happy boy!";
String ss1 = "Happy!";
String ss2 = ss1;
55
ndrumardelaborator
// afisarea sirurilor s1 si s2
System.out.println(s1);
// compararea sirurilor
int comparare = s1.compareTo(s2);
if (comparare < 0)
{
System.out.println("Sirul \"" + s1 + "\" este mai mic decat sirul"
+ " \"" + s2 + "\"");
}
else
{
if (comparare > 0)
{
System.out.println("Sirul \"" + s2 + "\" este mai mare decat"
+ " sirul \"" + s2 + "\"");
}
else
{
System.out.println("Sirul \"" + s1 + "\" este egal cu sirul \""
+ s2 + "\"");
}
}
if (s1 == s2)
System.out.println("Sirurile sunt egale!");
else
System.out.println("Sirurile sunt diferite!");
System.out.println(s1 == s2);
if (ss1.equals(ss2))
{
System.out.println("Sirul \"" + ss1 + "\" este egal cu sirul \""
+ ss2 + "\"");
}
else
{
System.out.println("Sirul \"" + ss1 + "\" nu este egal cu sirul"
+ " \"" + ss2 + "\"");
}
// concatenarea sirurilor
// sirul s1 este format din concatenarea valorii sale initiale cu
// cele ale sirului s2
s1 += s2;
56
String s3 = "opt zeci si trei";
// concatenarea a doua caractere la un sir

System.out.println(s3 + " este " + 8 + 3);
String s4 = "unsprazece";
// concatenarea rezultatului unei operatii aritmetice

System.out.println(8 + 3 + " este " + s4);
// utilizarea metodei valueOf(int i)pentru a reprezenta argumentul

// int ca si string
String myString1 = "opt zeci si trei este: " + String.valueOf(8)
+ String.valueOf(3);
String myString2 = String.valueOf(8) + String.valueOf(3)
+ " este: opt zeci si trei";
System.out.println(myString1);
System.out.println(myString2);
// declararea unui tablou de tip caracter

char[] carray = new char[30];
// utilizarea unui ciclu for pentru afisarea fiecarui caracter in

// parte a sirului
for (int index = 0; index < s2.length(); index++)
{
// utilizarea metodei charAt(index)pentru returnarea caracterului
// de la indexul specificat
carray[index] = s2.charAt(index);
System.out.print(carray[index]);
}
System.out.println("\n");
// utilizarea metodei replace pentru inlocuirea intr-un sir a unui

// caracter cu un alt caracter(carcterul 'H' este inlocuit
// cu caracterul 'X'
s1 = s1.replace('H', 'X');
// utilizarea metodei startsWith(String prefix)pentru a verifica

// daca sirul incepe cu prefixul specificat
if (ss2.startsWith("He"))
System.out.println("Sirul \"" + ss2 + "\" incepe cu prefixul He");
// utilizarea metodei startsWith(String prefix,int toffset) pentru

// a verifica daca in subsirul ce incepe de la indexul specificat
// (int/ toffset)din sir este precedat de sufixul respectiv
if (ss2.startsWith("pp", 2))
{
System.out.println("Sirul \"" + ss2
+ "\" include subsirul \"pp\" la pozitia 2");
}
57
ndrumardelaborator
// utilizarea metodei endsWith(String suffix)pentru a verifica daca

// sirul se termina cu sufixul specificat
if (ss2.endsWith("y!"))
{
System.out.println("Sirul \"" + ss2
+ "\" se termina cu subsirul y!");
}
// declararea unui sir de caractere (valoarea initiala este

// sirul vid "")
String m1 = new String();
// declararea si initializarea unui sir de caractere

String m2 = new String("Acesta este un sir");
// declararea celui de-al treilea sir si initializarea sa cu

// valoarea celui de-al doilea sir. aceasta valoare se va mentine
// chiar daca sirul s2 va suferi modificari
String m3 = m2;
// afisarea celor trei siruri

System.out.println(m1);
// cocatenarea sirului s2 cu sirul "modificat"

m2 += "modificat";
// afisarea noilor valori

char[] textchar = {'A', 'c', 'e', 's', 't', 'a', ' ', 'e', 's', 't',
'e', ' ', 'u', 'n', ' ', 's', 'i', 'r', '.' };
// metoda copyValueOf(char[]data) returneaza un sir format din

// caracterele specificate de vector (char[]textchar)
String n1 = String.copyValueOf(textchar);
System.out.print(n1);
String text = "Un sir declarat";

System.out.println("Sirul este:" + "\"" + text + "\"");
// utilizarea metodei substring(int beginIndex, int endIndex) pentru

// crea un un subsir dintr-un sir pornind de la pozitia beginIndex
// la pozitia endIndex a sirului
String subsir = text.substring(7, 15);
System.out.println("Subsirul de la pozitia 7 la 15: \"" + subsir
+ "\"");
58
String propozitie = "Problema principala este de a gasi grupul de"

+ " caractere din sirul curent si, cateodata, a"
+ " verifica daca caracterele exista in sir sau"
+ " nu. Atentie! grupul de caractere poate"
+ " forma un cuvant din sir sau poate fi o"
+ " parte a unui cuvant din sir.";
int siCount = 0;
int deCount = 0;
int index;
System.out.println("String-ul este:");
System.out.println(propozitie);
// gasirea lui "si"

index = propozitie.indexOf("si"); // gaseste primul "si"
while (index >= 0)
{
++siCount;
index += "si".length(); // sare la pozitia dupa ultimului "si"
index = propozitie.indexOf("si", index); // cauta "si" de la index
// la sfarsitul textului
}
// gasirea lui "de"

index = propozitie.lastIndexOf("de"); // gaseste ultimul de
while (index >= 0)
{
++deCount;
index -= "de".length(); // sare la pozitia de dinaintea
// ultimului "de"
index = propozitie.lastIndexOf("de", --index);
}
System.out.println("Textul contine " + siCount + " \"si\"\n"

+ "Textul contine " + deCount + " \"de\"");
}
}
59
ndrumardelaborator
8.2.ClasaStringBuffer
ListatuturorproprietilorimetodeloraleclaseiStringBuffersegsetelaadresa:
http://java.sun.com/javase/6/docs/api/java/lang/StringBuffer.html.
ExempluStringBuffer.java
public class ExempluStringBuffer

{
{
// StringBuffer este un String care poate fi modificat fara crearea
// unei noi instante a clasei
StringBuffer sb1 = new StringBuffer(); // declararea unui
// StringBuffer vid ce are
// capacitatea initiala
// de 16 caractere
// crearea unei instante ce are ca valoare initaial textul

// "Acesta este un StringBuffer"
StringBuffer sb2 = new StringBuffer("Acesta este un StringBuffer");
// declararea unui StringBuffer fara caractere ce are

// capaciatatea initiala de 20 de caractere
StringBuffer sb3 = new StringBuffer(20);
sb1 = new StringBuffer("Eu am mere");

sb3 = new StringBuffer("Eu am pere");
System.out.println(sb1);
// utilizarea metodei insert(int offset,char c) pentru a insera

// un caracter c la pozitia specificata offset
sb1.insert(6, 3);
System.out.println("Noul sir sb1 este: " + sb1);
sb1.insert(6, 3);
System.out.println("Noul sir sb1 este: " + sb1);
// transformarea SringBuffer intr-un String

String myString1 = sb2.toString();
// declararea unui string si initializarea sa cu valoarea

// StringBufferului declarat anterior
String myString2 = new String(sb2);
System.out.println("Sirul din StringBuffer este: " + myString1);
System.out.println("Sirul din StringBuffer este: " + myString2);
// declararea unui String Buffer

StringBuffer sir = new StringBuffer("12345678901234567890");
60
// afisarea lui
System.out.println("Sirul este: " + sir);
// folosirea metode replace(int start,int end,String str)

// pentru inlocuirea in sirul specificat a unui subsir cu un alt
// subsir(str)incepand de la pozitia start pana la pozitia end
sir.replace(2, 15, "abcdefghijk");
System.out.println("Noul sir este: " + sir);
// utilizarea metodei reverse() pentru inversarea sirului specificat

sir.reverse();
System.out.println("Noul sir inversat este: " + sir);

}
}
61
ndrumardelaborator
62
LABORATORUL7
9.Claseiprogramareorientatobiect
Utilizareaclaselornscriereadeprogramesencadreaznparadigmadeprogramareorientat
obiect(POOOOPObjectOrientedProgramming),carepresupunecreareunortipuridedate
complexecareseaseamn,nmulteaspecte,cuobiectereale.Astfel,acestetipuriconinatt
dateleutile,ctimetodeledeoperareasupraacestora.
Oclasvaconineproprieti(atribute)imetode(comportamente),ivadescrie,ntrunmod
abstract,naturaobiectuluicesedoreteafitranspusnprogram.
9.1.Termeniutilizainprogramareaorientatobiect
O clas este un tip de date ce ncapsuleaz att datele utile ct i modul de operare asupra
acestora.
Instaniereaesteprocesulprincareseobineunobiectcarearepropriasalocaiedememorie
ipropriulcodexecutabil.Unobiectesteoinstanauneiclase,adicesteconstruitpebaza
declaraiilordinclas.Utilizndoanalogie,oclasesteunplanaluneicase(practicundesen),
iarobiectul,sauinstana,estecasaconstruit.
Motenirea este mecanismul prin care se pot obine noi clase din clase deja existente. Noile
clasevormotenicaracteristici(proprietiimetode)aleclaseidebaz(superclasei).
Operaiaprincareseobineoclasnoudinunaexistentpoartdenumireadederivare.
Polimorfismulreprezintmecanismulcarepermiteaccesareaproprietilorimetodelorunui
obiectdeunanumittipprinintermediulunortipuridedatedincareacestaafostobinutprin
derivare.
9.2.Definiiauneiclase
Ceamaisimpldefiniieauneiclase,nJava,esteformatdintreicomponente:

Fig.15.Componenteleesenialealeuneiclase
63
ndrumardelaborator
1.Princonvenie,numeleclaselorJavatrebuiesnceapculitermare.Dacnumele
coninemaimuliatomilexicali,fiecaredintreeitrebuiesnceapculitermare.De
exemplu:

class ClasaAceastaRespectaConventiaDeNotare
{
2.Estefoarteindicatcafiecareclassfiescrisnpropriulfiier.Numelefiierului,n
modobligatoriu,trebuiesaibexactacelainumecucelalclaseiconinute.
Corpulclaseiconinedeclaraiiledeproprietiimetode.
9.2.1.Modificatorideacces
Programareaorientatobiectimpuneexistenaunuimecanismdecontrolasupraaccesuluila
clase i proprietile i metodele unui obiect. n Java, acest mecanism este implementat prin
modificatorideacces.
Exist4modificatorideacces: private, protected, publiciimplicit(atuncicndniciunul

dinceianteriorinusuntmenionai).Deasemenea,sepotevidenia4domeniidevizibilitatea
metodelor i proprietilor: clasa care conine metodele i proprietile, clasele derivate din
aceasta(subclase),pachetulncareseaflclasailumeaexterioar(zonapublic).
Tabelulurmtorprezintsemnificaiamodificatorilordeaccesdinpunctdevedereavizibilitii
proprietilorimetodelor.
Specificator Clas Subclas Pachet Zonapublic

private X
protected X X X
public X X X X
implicit X X
Modificatoriiprivateiprotectednupotfiaplicaiclaselor.
9.2.2.Alimodificatori
9.2.2.1.Modificatorulfinal
Pentru declaraiile de proprieti are semnificaia faptului c acea proprietate este constant
(nupoatefimodificat).
64
Metodelepurtndacestmodificatornumaipotfisupradefinitensubclase.
ncazulclaselor,finalprecizeazcaceaclasnumaipoatefiderivat(nuaremotenitori).
9.2.2.2.Modificatorulstatic
Acestmodificatorpoatefiutilizatnumaipentruproprietiimetode.
Proprietile i metodele declarate cu modificatorul static poart denumire de proprieti,

respectivmetodedeclas.Dacoproprietatesauometodnuconinemodificatorul static
ndeclaraie,atuncieasenumeteproprietate,respectivmetoddeinstan.
9.2.2.3.Modificatorulsynchronized
Acestmodificatoresteutilizatnaplicaiicareruleazmaimultefiredeexecuienparalel.
Modificatorulasigurexclusivitateaccesuluilaexecuie,astfelnctsnuaparerorideviolare
aaccesului.
9.2.3.Proprieti
Oproprietateesteunelementdedateasociatclasei.
Definirea/declarareproprietilorsefacelafelcancazulvariabilelor.Proprietilesedeclar
ninteriorulclasei,darnafaraoricreimetode.Declaraiilepotfiprecedatedemodificatoriide
accesprivate,protectedsaupublicipotfiiniializatenmomentuldeclarrii.
Proprietilepotfideinstan,prinurmarepotfiaccesatedoarprinnumelevariabileicareface
referirelaobiect,ideclas,caresuntcomunepentrutoateinstaneleipotfiaccesatedirect
prinnumeleclasei.
Modificrile fcute asupra unei proprieti de instan a unui obiect nu are efect
asupraproprietilordeinstanaunuialtobiect.

9.2.4.Metode
Ometodesteoparteaunuiprogramcareconinelogicapentruexecutareauneisarcini.De
fiecaredatcndtrebuieexecutatsarcinarespectivtrebuieapelatmetoda.
Principalul motiv pentru folosirea metodelor n programe este reducerea numrului de

instruciuni duplicate n program. De asemenea, folosirea metodelor duce la simplificarea
ntreineriiprogramului.Modificrilesuntfcutentrunsingurlocncodulmetodei.
nmodobligatoriumetodeletrebuiedeclarateninteriorulclaselor.
65
ndrumardelaborator
Declarareametodelor:
Formatgeneral:
<modificatori> <tip_returnat> <id_metoda>(<list_parametri>)

{
<declaratii_proprietati_si_metode>
}
Tipulreturnatpoatefiuntipdedateprimitivsauoreferinctreunobiect.Dacmetodanu
returneazdateseutilizeazcuvntulcheievoidpentrutipulreturnat.
A nu se confunda cuvntul cheie void cu 0. Zero este o valoare, pe cnd void

semnificabsenauneivalori.

Numelemetodeiestedatedeprogramator.Numeletrebuiesfiesugestivpentruceeaceface
metodaisrespecteconveniadedenumireJava.
Lista de parametri este format din datele de care metoda are nevoie pentru ai duce la
ndeplinire sarcina. Lista este format prin specificarea tipului de date i a numelui pentru
fiecareelementdedatetransmismetodei.Tipuldedatealparametruluiesteacelaicutipulde
date al unei variabile. Acesta spune mainii virtuale Java ct memorie s rezerve pentru
parametru i ce fel de date vor fi stocate. Numele parametrului este similar cu numele unei
variabile; este o etichet pentru o adres de memorie care conine datele transmise de
instruciuneacareapeleazmetoda.ncadruluneimetode,numeleparametruluisefolosete
lafelcaovariabil.
Numele unui parametru trebuie s reflecte natura datelor stocate de acesta. i acest nume
trebuiesrespecteconveniadedenumireJava.
Lista de parametri poate conine orici parametri, separai prin virgule, iar numele lor s fie
unice.
Lista de parametri este opional. Numai o metod care are nevoie de date transmise de
instruciunea care o apeleaz trebuie s aib o list de parametri. Totui, definiia metodei
trebuiesincludparantezele,chiardacnuexistolistdeparametri.
TransferulparametrilorsefacenJavaprinvaloare.
66
Modificatoriipotfi:
unspecificatordeacces:
o public
o private
o protected
unuldincuvintelerezervate:
o static(metodaestedeclas,nudeinstan)
o abstract (metod abstract ce trebuie s fac parte dintro clas abstract;
aceastmetodnuareimplementare)
o final(metodanupoatefisupradefinit)
o native
o synchronized
Numelemetodei,mpreuncutipulparametrilorpecareaceastaiareformeazsemnturasa.
Semnturatrebuiesfieunicncadrulaceleiaiclase.Potfidefinitemetodecuacelainume,
daravndsemnturidiferite,mecanismulfolositnumindusesuprancrcare(overloading).
9.2.5.Constructori
Un constructor este o metod special care este apelat automat la crearea unei instane a
uneiclase.
Dinpunctdevederetehnic,constructorulesteapelatnaintecaoperatorul newsitermine
execuia. Constructorul se folosete att pentru iniializarea proprietilor de instan ct i
pentruexecutareaunoroperaiilacreareaunuiobiect.
Unconstructorestedefinitcaoricemetodns:
numeleconstructoruluitrebuiesfieacelaicunumeleclasei;
constructorulnutrebuiesconininstruciuneareturn;
Se pot defini mai muli constructori pentru o clas, fiecare avnd semnturi diferite
(suprancrcareaconstructorului).
Dac programatorul nu scrie nici un constructor, Java utilizeaz un constructor implicit (creat
automat de Java). Constructorul implicit nu are list de parametri. Un constructor se
suprancarc prin definirea unuiconstructor care are o list de parametri. Acestase numete
constructorparametrizat(cuparametri).
Dac ntro clas este definit un constructor, indiferent de numrul de argumente pe

care le accept, Java nu mai creeaz constructorul implicit. Prin urmare, dac se
doreteunconstructorfrargumentedupcesadefinitunulcuargumentetrebuie

creatconstructorulfrargumentenmodexplicit.
67
ndrumardelaborator
Constructoruluneiclasepoateaveamodificatordeacces.
Dac modificatorul de acces este public, atunci se poate crea o instan a clasei
respective n orice alt clas.
Dac modificatorul de acces este protected, se pot crea instane ale clasei respective
doar n clasele care motenesc clasa respectiv.
Dac modificatorul de acces este private, nu se pot crea instane ale clasei n alte clase.
Dac modificatorul de acces este implicit, atunci nu se pot crea instane ale clasei dect n
clasele din acelai pachet n care este clasa pentru care se creeaz instana.
9.2.6.Declarareauneiinstaneauneiclase
La crearea unui obiect (instane) Java aloc memorie pentru toate proprietile de instan,
apoiapeleazconstructorul.
myClass x = new myClass();
Instruciuneademaisusimplictreioperaii:
Operatorul newceremainiiJavasrezerveunblocdememoriepentruinstan.Acest
bloc de memorie este suficient de mare pentru stocarea proprietilor de instan.
Operatorulnewreturneazadresabloculuidememorierezervat.
EstedeclaratovariabilreferinauneiinstaneaclaseimyClass,numitx.Referina
estedeclaratfolosindnumeleclasei.
A treia operaie const n a atribui referinei prima adres din blocul de memorie al
instanei. Referina (x) este folosit apoi n program ori de cte ori se face referire la
instanacreat.

n exemplul anterior sa declarat o referin i o instan a clasei ntro singur instruciune.
Celedoudeclaraiipotfiseparatendouinstruciuni:
myClass x;
x=new myClass();
Referinelordeclaratefinalenulepotfiatribuitealtevalori.
9.2.7.Accesullamembriiuneiclase
Dupceestedeclaratoinstanauneiclase,accesullamembriiclaseisefaceprinintermediul
uneireferineaclasei(variabila).
Pentruaobineaccesullaunmembrualuneiclase,sefolosetenumelereferinei,urmatde
operatorulpunctidenumelemembrului.
Exemplul urmtor definete clasa myClass, care are 3 membri. Acetia sunt o variabil de
instan numit student, un constructor i o metod numit print(). Variabila de instan
esteiniializatcunumruldeidentificarealunuistudent,dectreconstructor,ladeclararea
instanei.Instanaesteapoifolositpentruaapelametoda print(),careafieaznumelede
identificarealstudentului.
68
MyClass.java
class MyClass
{
int student;
MyClass()
{
student = 1234;
}
public void print()

{
System.out.println("Neata, student: " + student);
}
}
Demonstratie.java
class Demonstratie
{
public static void main(String args[])
{
//declararea unei instante a clasei MyClass
MyClass x = new MyClass();
//apelarea functiei print() folosind instant clasei MyClasss

x.print();
}
}
9.2.8.Suprancrcareametodelor
Ometodseidentificdupsemnturasa,carereprezintcombinaiantrenumelemetodeii
lista tipurilor parametrilor. Acesta nseamn c dou metode pot avea acelai nume, dar
parametridiferii.
Oclaspoateaveamaimultemetodecuacelainume,darsemnturafiecreimetodesfie
unicndefiniiaclasei.
Atunci cnd ntro clas exist dou metode cu acelai nume se spune c a doua metod
suprancarcprimametod.
1.Doumetodealeuneiclasenupotaveaaceeaisemntur.
2.Metodeadouclasediferitepotaveaaceeaisemntur.

69
ndrumardelaborator
Aceastideeesteilustratnurmtorulexemplu,ncareexistdoumetodenumite print().
Primaversiunenuareolistdeargumenteiafieazunmesajdentmpinareprestabilitde
fiecaredatcndesteapelat.Adouaversiuneconineuntextcarevafincorporatnmesajul
afiat. Astfel se poate opta ntre afiarea unui mesaj de ntmpinare generic sau un mesaj
personalizat.
MyClass.java
class MyClass
{
//functia print() fara parametrii
public void print()
{
System.out.println("Neata!");
}
//functia print cu parametru de tip String

public void print(String str)
{
System.out.println("Neata " + str);
}
}
Demonstratie.java
class Demonstratie
{
{
//declararea unei instante a clasei MyClass
MyClass x = new myClass();
/* apelarea functiei print(), functie fara parametrii,

folosind instant clasei MyClasss */
x.print();
/* apelarea functiei print(), functie cu parametru de tip String,

folosind instant clasei myClasss */
x.print("Student");
}
}
9.2.9.Cuvntulcheiethis
Ometodareacces,nmodimplicit,lavariabileledeinstanilacelelaltemetodealeclasein
careestedefinit.
70
Exist situaii n care se declar ntro metod o variabil care are acelai nume ca i o
proprietate de instan. O variabil declarat n interiorul unei metode se numete variabil
local.Dacoinstruciunedintrometodreferunnumedevariabil,Javafolosetevariabila
localnloculvariabileideinstancuacelainume.
SepoateceremainiivirtualeJavasfoloseascovariabildeinstannloculvariabileilocale
cu acelai nume, folosind cuvntul cheie this. Cuvntul cheie this permite referirea la
obiectulcurentalclasei.
MyClass.java
class MyClass
{
//functia print() fara parametrii
public void print()
{
System.out.println("Neata!");
}
public void print()

{
int student = 12;
// afiseaza variabila locala

System.out.println("Neata ,student: " + student);
// se afiseaza variabila de instanta utilizand cuvantul this

System.out.println("Neata ,student: " + this.student);
}
}
Demonstratie.java
class Demonstratie
{
{
MyClass x = new myClass();
x.print();
}
}
Urmtorulexempluprezintmodulcumsepoateutilizacuvntulcheiethispentruapelulunui
constructordininteriorulaltuiconstructor.
71
ndrumardelaborator
Dacsedoreteapelareaunuiconstructornmodexplicit,aceastinstruciunetrebuie
sfieprimanconstructor.

MyClass.java
class MyClass
{
int studentID;
String studentNume;
double media;
MyClass(int x, String y, double z)

{
studentID = x;
studentNume = y;
media = z;
}
MyClass(int x, String y)
{
// Apelam constructorul cu 3 argumente
this(x, y, 0);
}
MyClass()
{
// Apelam constructorul cu 2 argumente
this(0,"");
}
}
9.3.Creareaiutilizareclaselor(1)
Student.java
public class Student

{
private int student; // variabila de instanta
public Student()
{
// initializarea variabilei de instanta prin constructor
student = 1234;
}
72
public void print()

{
int student = 12;
// afiseaza variabila locala

System.out.println("Student: " + student);
// se afiseaza variabila de instanta utilizand cuvantul this

System.out.println("Student: " + this.student);
}
public void print(String str)

{
System.out.println("Student: " + str);
}
}
Clase.java
public class Clase

{
{
// declaraea unor instante ale unor clase
Student x, y, temp; // declararea referintelor
x = new Student(); // atribuie instanta referintei

/*
* operatorul new aloca dinamic memorie pentru instanta clasei (java
* rezerva memorie in timpul rularii, nu in timpul compilarii)
*/
y = new Student();
// accesul la membrii aceleiasi instante

temp = x;
temp = y;
/*
* apelarea metodei print() (metoda a clasei Student) folosind
* instanta clasei Student
*/
temp.print();
// metoda ce supraincarca prima metoda print();

temp.print("Ana");
}
}
73
ndrumardelaborator
9.4.Creareaiutilizareaclaselor(2)
Angajat.java
class Angajat
{
/*
* definirea celor 3 variabile de tip private adica sunt accesibile
* doar membrilor clasei in care sunt declarate.
*/
private String Nume;

private double salariu;
private Date aniversare;
/*
* definirea constructorului clasei (parametrii sunt cei definiti la
* initializarea obiectelor)
*/
public Angajat(String n, double s, int an, int luna, int zi)
{
Nume = n;
salariu = s;
/*
* crearea unui obiect de tip GregorianCalendar pentru afisarea
* timpului(datei)
*/
GregorianCalendar calendar = new GregorianCalendar(an, luna-1, zi);
// GregorianCalendar utilizeaza 0 pentru Ianuarie
aniversare = calendar.getTime();
}
// definirea metodei care preia parametrul nume

public String getNume()
{
return Nume;
}
// definirea metodei care preia parametrul salariu

public double getSalariu()
{
return salariu;
}
// definirea parametrului care preia data

public Date getaniversare()
{
return aniversare;
}
74
// definirea metodei pentru calculul salariului marit cu 5 %

public double Salariu(double Procent)
{
return salariu += salariu * Procent / 100;
}
}
Clase.java
public class Clase

{
{
// declararea unei instante a unei calse
Angajat[] obiect = new Angajat[3];
/*
* initializarea celor trei obiecte a clasei Angajat (initializarea
* tine cont de constructorul clasei Angajat)
*/
obiect[0] = new Angajat("Popescu Aurel", 750, 1987, 12, 15);
obiect[1] = new Angajat("Pintilie Mihai", 1000, 1989, 10, 1);
obiect[2] = new Angajat("Anghel Laurentiu", 1200, 1990, 3, 15);
// afisarea informatiilor despre toate obiectele Angajat

for (Angajat i : obiect)
{
System.out.println("Nume: " + i.getNume() + "\t|salariu: "
+ i.Salariu(5) + "\t|aniversare="
+ i.getaniversare());
}
}
}
9.5.Claseinterne
Definiiauneiclasepoateconinedefiniiauneialteclase.Acesteasenumescclaseimbricate.
Existdoutipurideclaseimbricate:staticeinestatice.
O clas imbricat static este definit cu modificator de acces static i nu are acces direct la
membrii clasei n cadrul creia este definit. Trebuie ca, mai nti, s se declare o instan a
claseiexterneiapoissefoloseascinstanacreatpentruaccesullamembriiclaseiexterne.
Oclasaimbricatnestaticestedenumitclasintern.Eaestedefinitninterioruluneialte
clasedenumitclasextern.Clasainternareaccesdirectlamembriiclaseiexternefrsse
declareoinstanaclaseiexterne.
75
ndrumardelaborator
Clasa intern poate conine proprieti de instan i metode membre. Totui, numai clasa
internareaccesdirectlaacetimembri.Clasaexternpoateaveaacceslamembriiuneiclase
interne declarnd o instan a clasei interne i folosind aceast instan pentru accesul la
membrii clasei interne. De asemenea, clasa intern nu este accesibil din exteriorul clasei
externe.
Oinstanauneiclaseinternepoatefideclaratnumaininteriorulclaseiexterne.
Figura.java
class Figura
{
// definirea unei metode membre a clasei
void metoda()
{
int alegere;
// definirea unui meniu pentru alegerea unei optiuni

do
{
System.out.println("Alegeti o figura geometrica");
System.out.println("cub: 1\tcon: 2\tcilindru: 3");
System.out.println("Pentru terminarea programului apasati +
+ tasta 4");
Scanner figura = new Scanner(System.in);

alegere = figura.nextInt();
if (alegere == 1)
{
// definirea unui obiect calcul de tip Cub
Cub calcul = new Cub();
// apelarea metodei membre a clasei Cub
calcul.calculare();
}
if (alegere == 2)
{
Con calcul = new Con();
calcul.calculare();
}
76
if (alegere == 3)
{
Cilindru calcul = new Cilindru();
calcul.calculare();
}
} while (alegere != 4);
}
// definirea clasei Cub ce este clasa inbricata in clasa Figura

class Cub
{
void calculare()
{
// float latura;
System.out.print("Introdu latura cubului: ");
Scanner Cub = new Scanner(System.in);
float latura = Cub.nextFloat();
System.out.println("Aria bazei cubului este: "

+ Math.pow(latura, 2));
System.out.println("Aria laterala a cubului este: "
+ 4 * Math.pow(latura, 2));
System.out.println("Aria totala a cubului este: "
+ 6 * Math.pow(latura, 2));
System.out.println("Volumul cubului este: "
+ Math.pow(latura, 3));
System.out.println("Diagonala bazei este: "
+ latura * Math.sqrt(2));
System.out.println("Diagonala cubului este: "
+ latura * Math.sqrt(3) + "\n");
}
}
// definirea clasei Con ce este clasa imbricata in clasa Figura

class Con
{
void calculare()
{
float raza;
float generatoarea;
float inaltimea;
System.out.print("Introdu raza conului: ");

Scanner con = new Scanner(System.in);
raza = con.nextFloat();
System.out.print("Introdu generatoarea conului: ");

generatoarea = con.nextFloat();
System.out.print("Introdu inaltimea conului: ");

inaltimea = con.nextFloat();
77
ndrumardelaborator
System.out.println("Aria bazei conului este: "

+ Math.PI * Math.pow(raza, 2));
System.out.println("Aria laterala a conului este: "
+ Math.PI * raza * generatoarea);
System.out.println("Aria totala a cubului este: "
+ Math.PI * raza * (raza + generatoarea));
System.out.println("Volumul conului este: "
+ Math.PI * Math.pow(raza, 2) * inaltimea / 3);
}
}
// definirea clasei Cilindru ce este clasa inbricata in clasa Figura

class Cilindru
{
void calculare()
{
float raza;
float generatoarea;
float inaltimea;
System.out.print("Introdu raza cilindrului: ");

Scanner cilindru = new Scanner(System.in);
raza = cilindru.nextFloat();
System.out.print("Introdu generatoarea cilindrului: ");

generatoarea = cilindru.nextFloat();
System.out.print("Introdu inaltimea cilindrului: ");

inaltimea = cilindru.nextFloat();
System.out.println("Aria bazei cilindrului este: "

+ Math.PI * Math.pow(raza, 2));
System.out.println("Aria laterala a cilindrului este: "
+ 2 * Math.PI * raza * generatoarea);
System.out.println("Aria totala a cilindrului este: "
+ Math.PI * raza * (raza + 2 * generatoarea));
System.out.println("Volumul conului este: "
+ Math.PI * Math.pow(raza, 2) * inaltimea);
}
}
}
Imbricate.java
public class Imbricate

{
{
78
// definirea unui obiect de tip Figura

Figura extern = new Figura();
/*
* apelarea metodei metoda() ce apartine clasei Figura prin
* intermediul obiectului extern
*/
extern.metoda();
}
}
79
ndrumardelaborator
80
LABORATORUL8
10.Motenirea
Proprietiledeinstanimetodelecomunemaimultorobiectesedeclarntrosingurclas
(ex.clasaA).Pentruobiectelenruditesepoatedeclaraonouclas(ex.clasaB)ceconineatt
membriiclaseiActimembriiparticulariclaseiB.
Esteinutilssedeclareidefineascaceeaimembriatttimpctexistosoluiemaibuni
anumemotenirea.
Oclasa(B copil)caremoteneteoaltclas(A -printe)areacceslatoimembriiclasei

printe,caicumacetiaarfifostdeclaraiidefiniipentruclasacopil.
Regulapentruastabilidacmotenireaestepotrivitpentruunanumitprogramsenumete
esteuniimpunecaunobiectsaiborelaiecuunaltobiectnaintedealmoteni.
Conformreguliiesteun,punemurmtoareantrebare:obiectulAesteunobiectB?.Dac
rspunsul este afirmativ, obiectul A poate s moteneasca obiectul B. Din punct de vedere
tehnicnuexistnimiccaresmpiediceoclassmoteneascoaltclas,daroricerelaiede
motenireartrebuisrespecteregulaesteun.
De exemplu, trstura comun ntre un student masterand i un student n primii ani este
aceea c ambii sunt studeni. Cu alte cuvinte, ambii au atribute i comportamente comune
tuturorstudenilor.Totui,unstudentmasterandareatributeicomportamentediferitedeale
altorstudeni.
Artrebuidefinitetreiclase:
clasaStudentcaredefineteatributeleicomportamentelediferitetuturorstudenilor;
clasaStudentMasterandpentrustudeniimasteranzi;
clasaStudentNelicentiatpentrustudeniidinprimiianidefacultate.
Aplicndregulaesteunobiectuluicarereprezintstudentulmasterand,punemurmtoarea
ntrebare: Studentul masterand este un student?. Rspunsul este afirmativ deci clasa
StudentMasterandpoatesmoteneascclasaStudent.
AplicndaceeairegulclaseiStudentNelicentiat(Studentulneliceniatesteunstudent?)
observmcStudentNelicentiatpoatemoteniclasaStudent.
Oclasmoteneteoaltclasfolosindcuvntulcheieextendsndefiniiaclasei.
81
ndrumardelaborator
Clasamotenitestenumitsuperclasa (clasaprinte),iarclasacaremotenetesenumete
subclasa(clasacopil).
Motenirea:
public class A
{
class B extends A
{
10.1.Accesullamembriiuneiclasemotenite
Accesullamembriiuneiclasesefacenfunciedespecificatoriideaccesfolosii.
Unmembrudeclaratca publicesteaccesibilpentruoricealtmembru,dinoricealtclas.Un
membrudeclaratca privateesteaccesibilpentruoricemetodmembrdinpropriaclas.Un
membrudeclaratca protectedesteaccesibilpentruoricemetodmembrdinpropriaclas
ipentrumetodelemembredinsubclaselecaremotenescpropriaclas.
Student.java
class Student
{
private int studentID;
public Student()
{
studentID = 1234;
}
protected void afisare()

{
System.out.println("studentul nr:" + studentID);
}
}
StudentMasterand.java
class StudentMasterand extends Student

{
}
82
Demonstratie.java
class Demonstratie
{
{
StudentMasterand ob = new StudentMasterand();
ob.afisare();
}
}
nexempluldemaisus,clasa Student,pelngconstructor,aredoimembri:oproprietatede
instan numit studentID i o metod membr numit afisare() ce afieaz pe ecran
valoarea proprietii studentID. Constructorul este folosit pentru iniializarea proprietiide
instan.
Clasa StudentMasterandnuareniciunmembru,darareacceslamembriipubliciiprotejai
ai clasei Student. Acesta nseamn c o instan a clasei StudentMasterand poate folosi
metoda afisare() din clasa Student, ca i cum metoda ar fi membr a clasei
StudentMasterand.
Aceastideeesteilustratdeinstruciuniledinmetoda main()aaplicaiei.Primainstruciune
declar o instan a clasei StudentMasterand. A doua instruciune folosete instana creat
pentruaapelametodaafisare().
La prima vedere metoda afisare() sar putea crede ca este membr clasei
StudentMasterand,deieste,defapt,membraclaseiStudent.
Motenirea este o relaie unidirecional. Cu alte cuvinte, o subclas are acces la membrii
publiciiprotejaiaisuperclasei,darsuperclasanuareacceslamembriipubliciiprotejaiai
subclaselor.
10.2.Apelareaconstructorilor
Atunci cnd o subclas motenete o superclas, la instanierea subclasei sunt implicai cel
puindoiconstructori.
Atuncicndsedeclaraoinstanasubclasei,Javaapeleazattconstructorulsubclaseicti
celalsuperclasei.
83
ndrumardelaborator
10.2.1.Folosireacuvntuluicheiesuper
Cuvntul cheie super este utilizat pentru referirea la membrii unei superclase n metodele
uneisubclase.
Cuvntulcheie supersefolosetelafelcumsefoloseteoreferinauneiinstanepentrua
referiunmembrualuneiclasedinprogram.
10.2.1.1.Folosireacuvntuluicheiesuper
Student.java
class Student
{
private int studentID;
Student()
{
studentID = 1234;
}
Student(int ID)
{
studentID = ID;
}
protected void afisare()

{
System.out.println("Studentul nr: " + studentID);
}

{
StudentiMasteranzi()
{
super(222);
}
public void afisare()

{
super.afisare();
}
84
Demonstratie.java
public class Demonstratie

{
{
StudentMasterand ob = new StudentMasterand();
ob.afisare();
}
}
nexempluldemaisus,nclasaStudentsuntdefiniidoiconstructoriambiifiindfolosiipentru
iniializarea proprietii de instan. Primul constructor folosete pentru iniializare o valoare
prestabilit,iaraldoileafolosetepentruiniializareovaloareprimitcaparametru.Sespune
caldoileaconstructorsuprancarcprimulconstructor.
Constructorul clasei StudentMasterand conine o singur instruciune ce folosete cuvntul

cheie superpentruaapelaconstructorulsuprancrcatalclasei Student.Metoda afisare()
dinclasa StudentMasterandconineosingurinstruciunecefolosetecuvntulcheie super
pentruaapelametodamembraafisare()aclaseStudent.
10.2.2.Motenireapemaimulteniveluri
n programele Java motenirea poate fi pe mai multe niveluri. Acesta permite unei clase s
moteneascmembridinmaimultesuperclase.Sefolosetemotenireapemaimulteniveluri
pentruagrupaobiectemaisimplenobiectemaicomplexe.
Unele limbaje de programare, cum ar fi C++, permit folosirea mai multor tipuri de motenire
multipl. n Java exist un singur tip de motenire multipl, numit motenire pe mai multe
niveluri (multilevel inheritance). Motenirea pe mai multe niveluri permite unei subclase s
moteneascdirectosingursuperclas.Totui,superclasarespectivpoatefi,larndulsu,o
subclasauneisuperclase.
10.2.2.1.Motenireapemaimulteniveluri
Persoana.java
class Persoana
{
private String nume;
Persoana()
{
nume = "Popescu";
}
85
ndrumardelaborator
protected void metodaNume()

{
System.out.println("Nume student: " + nume);
}
}
Student.java
//definirea unei clase ce mosteneste superclasa Persoane
class Student extends Persoana

{
private int student;
public Student()
{
student = 12345;
}
protected void metodaStudent()

{
System.out.println("ID Student: " + student);
}
}
// definirea unei clase ce mosteneste clasa Studenti,

// clasa ce mosteneste calasa Persoane

{
protected void metoda()
{
// apelarea metodei din clasa mostenita Persoane
metodaNume();
// apelarea metodei din clasa mostenita Studenti

metodaStudent();
}
}
Mostenire.java
public class Mostenire

{
{
86
StudentMasterand a = new StudentMasterand();

a.metoda();
}
}
nexemplulanteriorsaudefinittreiclase: Persoana, Student, StudentMasterand. Fiecare

clastreceprintestulesteun(studentulesteopersoan,iarunstudentmasterandesteun
student).Aceastanseamncsepotlegaceletreiclasentrorelaie,folosindmotenirea.
Motenireapemaimulteniveluripermiteuneisubclasesmoteneascosingursuperclas.
TotuinaplicaiesedoretecaStudentMasterand smoteneascattclasaStudent,cti
clasa Persoana. Se poate ocoli restricia impus de motenirea simpl crend mai nti o
relaiedemotenirentreclasa Persoana iclasa Student. Clasa Studentareacceslatoi
membriiprotejaiipubliciaiclasei Persoana.Apoisepoatecreaorelaiedemotenirentre
clasa Student i clasa StudentMasterand. Clasa StudentMasterand motenete toi
membrii publici i protejai ai clasei Student, ceea ce include i accesul la membrii publici i
protejaiaiclasei Persoana,deoarececlasa Student amotenitdejaaccesullaaceimembrii
prinmotenireaclaseiPersoana.
Acestexemplucreeazomotenirepemaimulteniveluri.Primulnivelesteformatdinclasele
Persoana i Student. Clasa Persoana este superclas, iar clasa Student este subclas. Al
doilea nivel este format din clasele Student i StudentMasterand: clasa Student este
superclas,iarclasaStudentMasterandestesubclas.
Se poate realiza orice numr de niveluri de motenire ntrun program cu condiia ca fiecare
classtreacdetestulesteun.Totuiestedepreferatsnuexisteunnumrmaimarede
trei niveluri deoarece acesta duce la creterea complexitii i face ca programul s fie mai
dificildentreinutiactualizat.
10.2.3.Supradefinireametodelorfolosindmotenirea
Ometodpermiteuneiinstaneauneiclasesimplementezeunanumittipdecomportament,
cum ar fi afiarea unei variabile de instan. O subclas motenete comportamentul unei
superclase,atuncicndareacceslametodelesuperclasei.
Uneori comportamentul unei metode membre a superclasei nu ndeplinete cerinele unei

subclase.Deexemplu,manierancaremetodamembrasuperclaseiafieazoproprietatede
instan nu este exact modul n care trebuie s afieze acea proprietate. n acest caz, se
definete n subclasa o nou versiune a metodei superclasei, incluznd instruciuni care
mbuntesc comportamentul metodei din superclas. Acesta tehnic este numit
supradefinire(methodoverriding).
87
ndrumardelaborator
A nu se confunda suprancrcarea (overloading) unei metode cu supradefinirea

(overriding)uneimetode.

Suprancrcareareprezintdefinireauneimetodecareareacelainumecuoaltmetod,dar
cuolistdeparametridiferit.
Supradefinirea reprezint definirea unei metode care are acelai nume cu o alta metod i
aceeailistdeparamteri,nsarecomportamentdiferit.
10.2.3.1.Supradefinireametodelorfolosindmotenirea
Salarii.java
class Salarii
{
private String nume;
private double salariu;
// definirea constructorului cu lista de parametrii

public Salarii(String n, double s)
{
nume = n;
salariu = s;
}
public String getNume()

{
return nume;
}

{
return salariu;
}
public double Salariu(double procent)

{
return salariu += salariu * procent / 100;
}
}
Manager.java
class Manager extends Salarii

{
private double bonus;
88
/*
* clasa Manager fiind o subclasa a clasei Salarii are acces la
* membrii acesteia publici si protejati
*/
public Manager(String n, double s)

{
/*
* apelarea constructorului din superclasa ce contine lista de
* parametri(n,s)
*/
super(n, s);
bonus = 0;
}

{
// super.getSalariu apelararea metodei getSalariu metoda a
// superclasei(Salarii)
return (super.getSalariu() + bonus);
}
public double setBonus(double b)

{
return bonus = b;
}
}
Mostenire.java
import java.util.*;
public class Mostenire

{
{
// construirea unui obiect de tip Manager
Manager sef = new Manager("Popescu Aurel", 4000);
sef.setBonus(500);
Manager secretar = new Manager("Anghel Razvan", 2500);

secretar.setBonus(200);
Salarii[] obiect = new Salarii[3];
// ocuparea matricii obiect cu instante de tip Manager si Salarii
obiect[0] = sef;
obiect[1] = secretar;
obiect[2] = new Salarii("Grigore Mihai", 2000);
89
ndrumardelaborator
// cresterea salariilor cu 5%
for (Salarii i : obiect)
{
// apelarea metodei Salariu
i.Salariu(5);
// afisarea informatiilor despre toate obiectele de tip Salarii

System.out.println("Nume=" + i.getNume() + "\tSalariu="
+ i.getSalariu());
}
}
}
10.2.4.Cuvntulcheiefinalimotenirea
Cuvntulcheie finalaredouautilizrinmotenire.nprimulrnd,poatefifolositmpreun
cuometodmembrasuperclaseipentruampiedicaosubclasssuprascrieometod:
Persoane.java
class Persoane
{
final void MesajAvertizare()
{
System.out.println("Aceasta metoda nu poate fi supradefinita.");
}
}
n al doilea rnd, poate fi folosit mpreun cu o clas pentru a mpiedica folosirea clasei
respectivecasuperclas(mpiedicalteclasesmoteneascclasarespectiv).
Persoane.java
final class Persoane

{
void MesajAvertizare()
{
System.out.println("Aceasta clasa nu poate fi mostenita.");
}
}
90
LABORATORUL9
11.Tratareaexcepiilor
ntrun program pot aprea dou tipuri de erori: erori de compilare i erori de execuie. O
eroaredecompilareapare,deobicei,atuncicndprogramatorulafcutogreealdesintaxla
scrierea codului (de ex. omiterea caracterului punct i virgule la sfritul unei instruciuni).
Acesteerorisuntuordescoperitedecompilator.
O eroare de execuie apare n timpul rulrii programului i poate avea diverse cauze:
introducerea de ctre utilizator a unor date de alt natur dect cele ateptate de program,
indisponibilitateauneiresurse(deex.unfiier),etc.
Erorile de execuie sunt mai grave dect erorile de compilare deoarece acestea apar
ntotdeauna, pe cnd eroarile de execuie apar numai n anumite situaii. Din acest motiv,
acesteeroritrebuieanticipateitrebuieinclusenprogrammodalitilelordedezvoltare.
11.1.Proceduridetratareaexcepiilor
Oprocedurdetratareaexcepiiloresteoporiuneaprogramuluicareconineinstruciunice
suntexecutatecndapareoanumiteroaredeexecuie.
Includereauneiproceduridetratareaexcepiilornprogramsenumetetratareaexcepiilor.
Anumite instruciuni dintrun program sunt susceptibile la generarea erorilor de execuie. De

obicei,acesteinstruciunidepinddesursedinafaraprogramului,cumarfidateintrodusede
utilizatorulprogramuluisauprelucrricarearputeacauzaerorideexecuie.
nlocsseverificedateleprovenitedinsurseexternesaudinalteprelucrrisemonitorizeaz
acesteinstruciuniisearuncoexcepiedacapareoeroaredeexecuie.Deasemenea,se
include n program instruciuni care sunt executate dac este aruncat o excepie. Aceast
procedursenumeteprindereauneiexcepii.
Instruciunilecetrebuiescmonitorizatetrebuiencadratentrunbloctry.
try
{
<instructiuni>;
}
Instruciunileexecutateatuncicndapareoexcepiesuntplasatentrunbloccatch.
91
ndrumardelaborator
catch (<tip_exceptie> <id_var_exceptie>)

{
<instructiuni>;
}
Mai exist o seciune finally ce conine instruciuni care se execut indiferent dac a
aprutoexcepiesaunu.Deobicei,nblocul finallyseplaseazinstruciunicareelibereaz
resurselerezervatedeprogram.
finally
{
<instructiuni>;
}
Fiecruibloc trytrebuiesicorespundcelpuinunbloc catchsauunbloc finally.Blocul

catchtrebuiesfieimediatdupblocultrypentruanusegeneraoeroaredecompilare.
Formatgeneral:
try
{
<instructiuni_test>;
}
[catch (<tip_exceptie1> <id_var_exceptie1>)
{
<instructiuni_tratare_exceptie1>;
}]
[catch (<tip_exceptie2> <id_var_exceptie2>)
{
<instructiuni_tratare_exceptie2>;
}]
[]
[finally
{
<instructiuni_care_se_executa_totdeauna>;
}]
Presupunemexemplul:
ImpartireLaZero.java
public class ImpartireLaZero

{
{
int x = 3;
int y = 0;
92
try
{
int z = impartire(x, y);
}
catch (ArithmeticException e)
{
System.out.println(e);
System.out.println("Exceptia Aritmetica: impartirea la 0");
}
}
public static int impartire(int a, int b)

{
int z = a / b;
return z;
}
}
Larularevaafia:
java.lang.ArithmeticException: / by zero
Exceptia Aritmetica: impartirea la 0
deoarece la sfritul blocului try se afla un bloc catch, care prinde excepiile de tip
ArithmeticException, reprezentate prin variabila e. Codul monitorizat de blocul try
genereazoeroarearitmeticatuncicndsencearcomprirelazero.
Cndsencearcomprirelazero,instruciuneancauzaruncoexcepiedemprirela
zero,careesteprinsdevariabilae.
Oseriedeinstruciunipotgeneramaimultetipurideerorideexecuie.Prinurmaresefolosesc
blocuricatchmultiplepentruainterceptafiecaretipdeexcepie.
Blocurile catchmultipletrebuiescplasateimediatdupblocul tryncarearputeafiaruncat

excepia.Deasemenea,blocurilecatchtrebuiesfieplasateunuldupaltul.
Atunci cnd apare o excepie, Java o arunc ctre blocurile catch care urmeaz dup blocul
try,nordineancareaparacesteanprogram.Dacexistdoublocuri catchiprimulbloc
prindeexcepia,aceastanumaiajungelaaldoileabloc catch,deoareceestetratatnprimul
bloc.
93
ndrumardelaborator
Demo1.java
public class Demo1

{
{
try
{
int a[] = new int[4];
a[0] = 0;
a[1] = 10;
a[2] = 5;
a[3] = a[0] / a[4];
}
{
System.out.println("Eroare: nu se poate imparti la 0);
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("Eroare: s-a depasit indexul vectorului a);
}
}
Rezultatulrulrii:
Eroare: s-a depasit indexul vectorului a

java.lang.ArrayIndexOutOfBoundsException: 4
Excepiaprinsestededepireaindexului:ArrayIndexOutOfBoundsException.
Demo2.java
public class Demo2

{
{
try
{
a[0] = 0;
a[1] = 10;
a[2] = 5;
a[3] = a[1] / a[0];
}
94
{
System.out.println("Eroare: nu se poate imparti la 0");
}
{
System.out.println("Eroare: s-a depasit indexul vectorului a");
}
}
}
Rezultatulrulrii:
Eroare: nu se poate imparti la 0

Excepia prins este o excepie aritmetica de mprire a unui numr la zero:

ArithmeticException.
Demo3.java
public class Demo3

{
{
try
{
a[0] = 0;
a[1] = 10;
a[2] = 5;
a[3] = a[1] / a[0];
a[3] = a[0] / a[4];
}
{
}
{
}
}
}
95
ndrumardelaborator
Rezultatulrulrii:
Eroare: nu se poate imparti la 0

PrimaeroareinterceptatestedetipArithmeticException.
ExemplulurmtorilustreazfolosireabloculuifinallyntrunprogramJava:
DemoFinally.java
public class DemoFinally

{
{
try
{
a[0] = 0;
a[1] = 10;
a[2] = 5;
a[3] = a[0] / a[4];
}
{
}
{
}
finally
{
System.out.println("Executarea blocului finally");
}
}
}
Rezultatulrulrii:
Eroare: s-a depasit indexul vectorului a

Executarea blocului finally
96
11.1.1.Blocuritryimbricate
Exist situaii cnd se combin dou sau mai multe blocuri try, plasnd un bloc try n
interiorul unui alt bloc try. Acest procedeu se numete imbricarea blocurilor try, iar blocul
internsenumetebloc tryimbricat.Colectiv,acesteasenumescperechiimbricatedeblocuri
try.
Fiecare bloc try dintro pereche imbricat trebuie s aib unul sau mai multe blocuri catch
sau un bloc finally, care prind excepiile. Blocurile catch sunt plasate imediat dup blocul
trycorespunztor,lafelcaatuncicndsescriublocuritrysimple.
Atuncicndoinstruciunedinblocultryinterndeterminaruncareauneiexcepii,Javaverific
dac blocurile catch asociate cu blocul try intern pot sa prind excepia. Dac nici unul din
aceste blocuri nu poate s prind excepia aruncat, sunt verificate blocurile catch asociate
blocului tryextern.Dacnicinacestfelexcepianuestetratatatunciexcepiaestetratat
deproceduraimplicit.
Demo.java
public class Demo

{
{
try
{
try
{
a[0] = 10;
a[1] = 0;
a[2] = a[3] / a[1];
}
{
System.out.println("S-a im partit la 0!!!!!");
System.out.println("Eroare:" + e);
}
}
{
System.out.println("S-a depasit indexul!!!!");
System.out.println("Eroare:" + e);
}
}
}
97
ndrumardelaborator
Rezultatulrulrii:
S-a depasit indexul!!!!

Eroare:java.lang.ArrayIndexOutOfBoundsException: 3
11.2.Lucrulcuexcepiineinterceptate
Deintimpulexecuieiprogramuluipotapreafoartemulteexcepii,nuestenevoiessescrie
cteunbloc catchastfelnctsfieprinsetoate.Oriceexcepiepentrucarenuexistunbloc
catchesteinterceptatdeblocul catchimplicitdinJava,numitprocedurimplicitdetratare
aexcepiilor(defaulthandler).
Oridecteoriprindeoexcepie,proceduraimplicitafieazdoutipurideinformaii:unir
decaracterecaredescrieexcepiaaprutionregistrareastivei.nregistrareastiveiaratce
execut programul, ncepnd cu punctul n care a aprut excepia i terminnd cu punctul n
careexecuiaprogramuluisancheiat.
Demo.java
public class Demo

{
{
int a = 0, b = 2, c;
c = b / a;
}
}
Rezultatulrulrii:
Exception in thread "main" java.lang.ArithmeticException: / by zero

at Demo.main(Demo.java:6)
Primalinieestemesajulcaredescrieexcepia.Adoualinieestenregistrareastivei,carespune
cexcepiaaaprutinlinia6dinmetodamain()aprogramuluiDemo.java.Aceastaestelinia
n care se face calculul mpririi lui 2 la 0. Pe acest linie se termin programul odat cu
aruncareaexcepiei.
Dac excepia este generat de o instruciune dintro metod apelat de metoda main(),
nregistrarea stivei include ambele metode, artnd calea pn la instruciunea care a cauzat
excepia.
98
Demo.java
public class Demo

{
{
metoda();
}
static void metoda()

{
int a = 0, b = 2, c;
c = b / a;
}
}
Rezultatulrulrii:
Exception in thread "main" java.lang.ArithmeticException: / by zero

at Demo.metoda(Demo.java:9)
at Demo.main(Demo.java:4)
Prima linie este mesajul care descrie excepia. ncepnd cu a doua linie ncepe nregistrarea
stivei.Citindnregistrareastiveincepndcuultimalinie:maintiesteapelatfuncia main()
a programului Demo.java, apoi n linia 4 a fost apelat metoda metoda(). Linia 9 a
programului,carefacepartedindefiniiametodei metoda(),estepunctulncaresancheiat
execuiaprogramului,dincauzauneiexcepii.
11.3.Metodecarenutrateazexcepiile
Nuesteobligatoriucaometodcarearuncoexcepiesoitrateze.Totui,antetulmetodei
trebuiesspecificeexcepiilecarepotfigeneratedemetodarespectiv.Pentruaapelametoda
trebuie s se includ n program un bloc try..catch care trateaz excepiile ce nu sunt
interceptatedemetod.
Sespecificexcepiilelansatefolosindcuvntulcheie throwsnantetulmetodei,duplistade
parametri.Dacsunmaimultetipurideexcepii,elevorfiseparateprinvirgule.
Exemplulurmtorilustreazspecificareaexcepilorcaresuntaruncate,darnuiinterceptarea
dectremetod.
Metoda myMethod() poate arunca dou excepii: ArithmeticException i

ArrayIndexOutOfBoundsException.Totuimetoda myMethod()nuprindeniciunadintre
aceste excepii. Metoda main() prinde excepia ArithmeticException, dar las excepia
ArrayIndexOutOfBoundsExceptionnseamaproceduriidetratareimplicitdinJava.
99
ndrumardelaborator
Demo.java
public class Demo

{
static void myMethod() throws ArithmeticException,
ArrayIndexOutOfBoundsException
{
a[0] = 10;
a[1] = 0;
a[2] = a[0] / a[1];
System.out.println("myMethod");
}

{
try
{
myMethod();
}
{
System.out.println("S-a im partit la 0!!!!!");
System.out.println("Eroare: " + e);
}
}
}
11.4.Excepiiverificateineverificate
Claseledeexcepiisuntmpritendougrupuri:verificateineverificate.Excepiileverificate
trebuiesfieinclusenlistadeexcepiiaruncatedeometod;dacmetodarespectivpoate
sa arunce excepia, dar nu o i trateaz. Compilatorul verific dac exist blocuri catch care
trateazacesteexcepii.
Cualtecuvinteoexcepieverificattrebuietratatexplicit,fieprininterceptatreantrunbloc
catch,fieprindeclarareacaexcepiearuncat.
Execpiile neverificate nu sunt obligatoriu s fie incluse n lista de excepii aruncate de o

metoda, deoarece compilatorul nu verific dac exist un bloc catch care trateaz aceste
excepii. Majoritatea excepiilor, att verificate, ct i neverificate, sunt definite n pachetul
java.lang,careesteimportatimplicitntoateprogrameleJava.
100
Urmtorultabelprezintopartedinexcepiileverificate:
Excepie Descriere
ArithmeticException Eroarearitmetic,cumarfimprirealazero
ArrayIndexOutOfBoundsException Indexulmatriceiadepitlimitele
ArrayStoreException Atribuireaunuitipincompatibilunuielemental
matricei
ClassCastException Conversieinvalid
IllegalArgumentException Argumentinvalidfolositpentruapelareauneimetode
IllegalMonitorStateException Operaiedemonitorizareilegal,cumarfiateptarea
unuifirdeexecuieblocat
IllegalStateException Mediulsauaplicaiaseaflntrostareincorect
IllegalThreadStateException Operaiasolicitatnuestecompatibilcustarea
curentafiruluideexecuie
IndexOutOfBoundsException Untipoarecaredeindexadepitlimitele
NegativeArraySizeException Matricecudimensiunenegativ
NullPointerException Utilizareauneireferienule
NumberFormatException Conversieinvalidaunuiirdecaraterentrun
formatnumeric
SecurityException Incercaredencalcareasecuritii
StringIndexOutOfBoundsException Incercaredeindexaredincolodelimiteleunuiirde
carcatere
UnsupportedOperationException Afostntlnitooperaieneacceptat
Urmtorultabelprezintopartedinexcepiileneverificate:
Excepie Descriere
ClassNotFoundException Clasanuafostgsit
CloneNotSupportedException ncercareadeaclonaunobiectcarenu
implementeazinterfaaCloneable
IllegalAccessException Accesullaoclasesteinterzis
InstantiationException ncercareadeacreeaoinstanauneiclaseabstracte
sauauneiinterfee
InterruptedException Unfirdeexecuieafostntreruptdeunaltfirde
execuie
NoSuchFieldException Afostsolicitatuncmpcarenuexist
(NoSuchMethodError Afostsolicitatometodacarenuexist
IOException Aaprutoexcepientimpuluniprocessde
intrare/ieire
SQLException Aaprutoexcepientimpulinterconectriicuun
sistemdegestionareabazelordedatefolosindSQL
11.5.TratareaexceptiilrfolosindsuperclasaException
Toate tipurile de excepii din Java sunt clase derivate din clasa Exception, astfel c, prin
mecanismuldepolimorfism,ovariabildetipExceptionpoateprindeoriceexcepie.
101
ndrumardelaborator
Demo.java
public class Demo

{
{
try
{
a[0] = 0;
a[1] = 10;
a[2] = 5;
a[3] = a[0] / a[4];
}
catch (Exception e)
{
System.out.println("A aparut o eroare!");
}
finally
{
System.out.println("Executarea blocului finally");
}
}
}
Rezultatulrulrii:
A aparut o eroare!
Executarea blocului finally
Acesttipdetratarearedezavantajulcnusepoateprecizatipuleroariiaprute.
11.6.Exemple
11.6.1.ExcepiideI/O
ScanExceptii.java
import java.util.*;
public class ScanExceptii

{
{
Scanner scanner = new Scanner(System.in);
System.out.print("Introduceti un numar: ");
double d = 0;
boolean numar = false;
102
while (!numar)
{
try
{
String s = scanner.nextLine();
/*
* initializeza variabila d cu valoarea specificata de String in
* cazul in care String poate fi reprezentat ca o valoare double
*/
d = Double.parseDouble(s);
numar = true;
}
catch (NumberFormatException e)
{
/*
* NumberFormatException-valoarea String nu poate fi convertita
* intr-o valoare double
*/
System.out.println("Nu ai inserat un numar valid.
+ Incearca din nou ");
System.out.print("Introduceti un numar: ");
}
}
System.out.println("Ai introdus: " + d);

// inchiderea Scanner
scanner.close();
}
}
11.6.2.Excepii:Depireaindexuluiunuivector
DepasireIndex.java
public class DepasireIndex

{
{
int[] Array = { 0, 1 };
try
{
System.out.println("Intrare in blocul try");
System.out.println(Array[2]);
System.out.println("Iesire din blocul try");
}
{
System.out.println("Exceptie aritmetica");
}
103
ndrumardelaborator
{
System.out.println("Exceptie index depasit");
// instructiunea return-iesirea din metoda return;
}
Finally
{
System.out.println("Blocul Finally este intodeaua executat");
}
System.out.println("Instructiune de dupa blocul try");

}
}
11.6.3.Excepii:Vectorcudimensiunenegativ
Negative.java
public class Negative

{
{
int x = 0, y = 7, z;
int vector[];
try
{
System.out.println("Intrarea in blocul try.");
// declararea unui vector cu dimensiune negativa
vector = new int[x - y];
System.out.println("Iesirea din blocul try.");
// prinderea exceptiei
}
catch (NegativeArraySizeException e)
{
System.out.println("Exceptia consta intr-un tablou
+ de dimensiune negativa.");
/*
* executarea blocului finally care se executa indiferent daca
* apar sau nu exceptii
*/
}
finally
{
// redeclararea vectorului
vector = new int[y - x];
System.out.println("Blocul finally este intodeauna executat.");
}
104
System.out.println("Executia de dupa blocurile try-catch

+ si finally.");
System.out.println("Depasirea indexului unui vector.");
try
{
// initializarea vectorului
for (int i = 0; i <= vector.length; i++)
vector[i] = i;
// prinderea exceptiei
}
{
System.out.println("Exceptie index depasit");
try
{
// realizarea unei operatii de impartire a unui intreg la 0
z = y / x;
/*
* prinderea exceptiei generate de impartirea unui intreg
* la 0 si tratatrea ei
*/
}
catch (ArithmeticException i)
{
System.out.println("Exceptie aritmetica");
z = x / y;
System.out.println(z);
}
}
}
}
11.6.4.Excepii:NullPointerException
NullPointer.java
public class NullPointer

{
{
Integer Val = new Integer(10);
try
{
Val = null;
int i = Val.intValue();
System.out.println(i);
}
105
ndrumardelaborator
catch (NullPointerException e)
{
System.out.println("Exceptia consta in faptul ca
+ obiectul este este null.");
}
}
}
11.6.5.Excepii:ArrayIndexOutOfBoundsException
RandomIndex.java
public class RandomIndex

{
{
// declararea unei matrici de 5 elemente cu initializare
int[] Array = { 0, 1, 2, 3, 4 };
// initializarea variabilei index cu 0
int index = 0;
// crearea unui ciclu: instructiunile sunt executate de 10 ori
for (int i = 0; i < 10; i++)
{
/*
* Math.random() genereaza un nr aleator intre 0.0-1.0 de tip
* double. Se imulteste cu 10 pentru a genera un nr intre 0 si 10
*/
index = (int) (Math.random() * 10);
try
{
System.out.println("La indexul " + index + " valoarea este: "
+ Array[index]);
}
{
System.out.println("Indexul " + index
+ " depaseste dimensiunea.");
}
}
}
}
106
LABORATORUL10
12.Interfee
Interfeele implementeaz conceptul programrii orientate obiect de separarea a modelului

unuiobiectdeimplmentareasa.Ointerfadefinetemetode,darnuiimplementarealor.
O clas care implementeaz o interfa trebuie s ofere implementarea efectiv a metodelor

declarateninterfa.
Deasemenea,ointerfapoateconineideclaraiideconstante.
Practic,ointerfaesteunansambludemetodefrimplementareideclaraiideconstante.
Toatemetodeledeclaratentrointerfaau,implicit,modificatoruldeaccespublic.
Formatgeneral:
[<modif_acces>] interface <Nume_Interfata>

[extends <Super_Interfata1>[, <SuperInterfata2>[, ...]]]
{
<declaratii_de_constane_si_metode>
}
Oclasimplementeazointerfaprinutilizareacuvntuluicheieimplements.
Urmtoareleexempleprezintmodulncareseutilizeazinterfeele.
Masina.java
interface Masina
{
String formatedText = "\nDetalii masina:"; // folosit pentru afisare
String getMarca();
String getCuloare();
void setCuloare(String value);
float getGreutate();
void setGreutate(float value);
int getPutereMotor();
void setPutereMotor(int value);
String getTipCombustibil(); // "benzina", "motorina"...
void setTipCombustibil(String value);
107
ndrumardelaborator
int getPret();
void setPret(int value);
void afiseazaDetalii();
}
Dacia.java
class Dacia implements Masina

{
String culoare = "albastru"; // valori implicite
float greutate = (float) 1500.00;
int putereMotor = 70;
String tipCombustibil = "benzina";
int pret = 10000;
public String getMarca()

{
return "Dacia";
}
public String getCuloare()

{
return culoare;
}
public void setCuloare(String value)

{
culoare = value;
}
public float getGreutate()

{
return greutate;
}
public void setGreutate(float value)

{
greutate = value;
}
public int getPutereMotor()

{
return putereMotor;
}
public void setPutereMotor(int value)

{
putereMotor = value;
}
108
public String getTipCombustibil()

{
return tipCombustibil;
}
public void setTipCombustibil(String value)

{
tipCombustibil = value;
}
public int getPret()

{
return pret;
}
public void setPret(int value)

{
pret = value;
}
public void afiseazaDetalii()

{
System.out.println(formatedText);
System.out.println("Marca = Dacia");
System.out.println("Culoare = " + culoare);
System.out.println("Greutate = " + String.valueOf(greutate));
System.out.println("Putere motor = " + String.valueOf(putereMotor));
System.out.println("Tip combustibil = " + tipCombustibil);
System.out.println("Pret = " + String.valueOf(pret));
}
}
Interfete.java
class Interfete
{
{
Dacia masina1 = new Dacia();
masina1.afiseazaDetalii();
Dacia masina2 = new Dacia();

masina2.setCuloare("rosu");
masina2.setPret(34000);
masina2.setGreutate((float) 1345.70);
masina2.afiseazaDetalii();
}
}
109
ndrumardelaborator
Instrument.java
interface Instrument
{
// defineste o metoda fara implementare
void play();
}
Pian.java
class Pian implements Instrument

{
// clasa care implementeaza interfata
// trebuie sa implementeze, obligatoriu, metoda play
public void play()
{
System.out.println("Canta un Pian!");
}
}
Vioara.java
class Vioara implements Instrument

{
public void play()

{
System.out.println("Canta o Vioara!");
}
Muzica.java
public class Muzica

{
// clasa principala
static void play(Instrument i)
{
// metoda statica care porneste un instrument generic
// ce implementeaza interfata Instrument
i.play();
}
static void playAll(Instrument[] e)

{
for (int i = 0; i < e.length; i++)
play(e[i]);
}
110

{
Instrument[] orchestra = new Instrument[2];
int i = 0;
orchestra[i++] = new Pian();
orchestra[i++] = new Vioara();
playAll(orchestra);
}
}
111
ndrumardelaborator
LABORATORUL11
13.Fluxurideintrare/ieiere(fiiere)
Datorit faptului c informaiile prelucrate de majoritatea programelor se stocheaz pe

suporturi externe, este necesar existena unor clase pentru operaiile de lucru cu aceste
suporturi.
Pentru ca un program Java s aduc date din surse externe trebuie s deschid un canal de
comunicaie(flux)ctresursaexternisciteascdatelerespective.nmodsimilar,pentrua
stoca datele dintrun program pe o surs extern trebuie s se deschid un flux ctre sursa
externissescriedatelepeea.
Java include un numr mare de clase pentru lucrul cu fiiere i fluxuri, concepute pentru
operaiiledestocareitransferaledatelor.
13.1.Fiiereisistemedefiiere
Un fiier reprezint un grup de octei nrudii. Un sistem de fiiere este un produs software
folositpentruorganizareaipstrareafiierelorpeundispozitivsecundardestocare.
Fiecare fiier are proprieti care l descriu. Sistemul de fiiere determin tipul proprietilor
caredescriufiierul.nmodobinuit,acestanseamnnumelefiierului,permisiuniledeacces,
dataioraultimeimodificriafiierului.ngeneral,celetreipermisiunideaccesfolositesunt:
citire/scriere(read/write),numaicitire(readonly)iexecuie.
Fiierelesuntorganizatendirectoareisubdirectoare.Directorulaflatpepoziiaceamainalt
a ierarhiei se numete director rdcina. De aici ncepe ntreaga ierarhie de directoare i
subdirectoare.Colectiv,directoarelesisubdirectoareleformeazstructuradedirectoare.
13.2.ClasaFILE
Esteinclusnpachetuljava.ioidefinetemetodeutilizatepentruinteraciunilecusistemul
defiiereinavigareanstructuradedirectoare.
CndsecreeazoinstanaclaseiFilesefoloseteunuldinceitreiconstructoriaiclasei:
File obj = new File(String directory);

File obj = new File(String directory, String fileName);
File obj = new File(String directoryObject, String fileName);
Primulconstructornecesittransmitereaciideacceslafiier.Demulteoricaleadeacceseste
o ierarhie de directoare terminate cu directorul de care are nevoie programul. De exemplu,
112
D:\Laborator_Java \test este o cale de acces care ajunge la subdirectorul test din directorul
aplicatiidepepartiiaD.
Al doilea constructor are nevoie de doi parametrii. Primul parametru este calea de acces la
director,iaraldoileaparametruestenumeleunuifiierconinutnultimulsubdirectordincalea
deaccesspecificat.
Altreileaconstructorestefoarteasemntorceceldealdoilea,darcaleadeaccesladirector
estetransmiscaoinstanclaseiFile,nucaunirdecaractere.
Aceticonstructorinucreeazundirectorsauunfiier.
Dupceprogramulareladispoziieocaledeacceslaundirectorsauunfiier,potfiapelate
metodedefinitenclasaFile.
MetodedefinitenclasaFilesuntprezentatesinteticntabelulurmtor:
Metod Descriere
isFile() Returneazvaloareabooleantruedacobiectul
esteunfiier.Metodareturneazvaloarefalsecnd
obiectulnuestefiiersauinstanaclaseiFilereferun
director,unsubdirector,uncanalsauundriverde
dispozitiv.
isAbsolute() Returneazvaloareabooleantruedacfiierul
conineocaledeaccesabsolutaltfelreturneaz
valoareafalse.
boolean renameTo(File newName) Redenumeteundirector,subdirectorsauunfiier,
folosindnumeletransmiscaargument.
delete() tergeunfiierdepesursaextern.
void deleteOnExit() tergefiieruldupcemainavirtualJavatermin
execuia.
boolean isHidden() Returneazvaloareabooleantruedacfiierulsau
caleadeaccesesteascuns;altfelreturneazvaloarea
booleanfalse.
boolean setLastModified(long ms) Modificmarcatemporalafiierului.Marca
temporalfurnizatcaargumenttrebuiesspecifice
dataiorainmilisecunde,ncepndcu1ianuarie
1970iterminndcudataioracurent.
boolean setReadOnly() Stabiletepermisiuneadeaccesnumaipentrucitire.
compareTo() Compardoufiiere.
length() Returneazlungimeafiieruluinoctei.
isDirectory() Returneazvaloareabooleantruedacobiectuleste
undirector;altfelreturneazvaloareabooleanfalse.
113
ndrumardelaborator
canRead() Returneazvaloareabooleantruedacdirectorul
saufiierularepermisiunedecitire;altfelreturneaz
valoareabooleanfalse.
canWrite() Returneazvaloareabooleantruedacdirectorul
saufiierularepermisiunedescriere;altfelreturneaz
valoareabooleanfalse.
exists() Returneazvaloareabooleantruedacdirectorul
saufiierulexist;altfelreturneazvaloareaboolean
false.
getParent() Returneazcaleadeaccesladirectorulprinteal
subdirectorului.
getAbsolutePath() Returneazcaleadeaccesabsolutasubdirectorului.
getPath() Returneazcaleadeaccesasubdirectorului.
getName() Returneaznumeledirectoruluisauafiierului.
Urmtoareaaplicaieilustreazutilizareaacestora.
DemoFile.java
import java.io.File;
public class DemoFile

{
{
File obj = new File("\\Laborator_Java\\DemoFile");
System.out.println("Nume:" + obj.getName());
System.out.println("Cale:" + obj.getPath());
System.out.println("Despre cale:" + obj.getAbsolutePath());
System.out.println("Parinte:" + obj.getParent());
System.out.println("Existenta:" + obj.exists());
System.out.println("Scriere:" + obj.canWrite());
System.out.println("Citire:" + obj.canRead());
System.out.println("Director:" + obj.isDirectory());
System.out.println("File:" + obj.isFile());
System.out.println("Cale absoluta:" + obj.isAbsolute());
System.out.println("Length:" + obj.length());
}
}
Rezultatulrulrii:
Nume: DemoFile
Cale: \Laborator_Java\DemoFile
Despre cale: D:\Laborator_Java\DemoFile
Parinte: \Laborator_Java
Existenta: true
Scriere: true
Citire: true
114
Director: true
File: false
Cale absoluta: false
Length: 0
13.2.1.Afiarealisteidefiieredintrundirector
Sepoatereturnaconinutulunuidirectorapelndmetodalist().
Metodalist()returneazuntabloudeiruridecaractereconinndnumelefiierelorstocate
ntrun director. Metoda list() poate fi folosit numai pentru directoare, de aceea este
recomandatsseapelezemetoda isDirectory()pentruaverificadacobiectulestesaunu
director,naintedeapelareametodei.
Exemplulurmtorilustreazfolosireametodelor list()i isDirectory()pentruobinerea

iafiareaconinutuluiunuidirector.
DemoFileDirector.java
import java.io.File;
public class DemoFileDirector

{
{
// atribuirea numelui directorului unui sir de caractere "dir"
String dir = "/acest_fisier";
// transmiterea sirului "dir" constructorului clasei File
File file1 = new File(dir);
// verificarea daca exista director
if (file1.isDirectory())
{
// afisarea numelui directorului
System.out.println("director: " + dir);
// apelarea metodei list() pentru obtinerea continutului
// directorului, care este stocat intr-o matrice de caractere,
// numita str1[]
String str1[] = file1.list();
// parcurgerea elementelor matricii
for (int i = 0; i < str1.length; i++)
{
// transmiterea fiecarui element constructorului clasei File
File file2 = new File(dir + "/" + str1[i]);
// stabilirea daca elementul matricii este un director
{
System.out.println("Director: " + str1[i]);
String str2[] = file2.list();
115
ndrumardelaborator
for (int j = 0; j < str2.length; j++)

{
File file3 = new File(dir + "/" + str1[i] + "/" + str2[j]);
System.out.println("Director: " + str2[j]);
else
continue;
}
}
else
continue;
}
}
else
System.out.println(dir + " nu este un director");
}
}
Rezultatulrulrii:
director: /acest_fisier
Director: test1
Director: test1_1
Director: test2
Director: test2_1
Structuradirectorului:
13.3.Fluxuri
Java include mai multe clase pentru fluxuri, construite pe baza a patru clase abstracte:
InputStream,OutputStream,ReaderiWriter.
116
13.3.1.Scriereantrunfiier
Pentruaputeascriedatentrunfiiertrebuieca,mainti,ssecreezeunfluxdeieirepentru
fiier.Unfluxdeieiredefiieredeschidefiierul,dacexist,saucreeazunnoufiierdacnu
exist.Dupcesedeschideunfluxdefiiere,sepoatescriedatenfiierfolosindunobiectde
scrierePrintWriter.
Se deschide un flux de ieire pentru fiiere folosind constructorul clasei FileOutputStream,

cruiaisetransmitenumelefiieruluipecaredorimsldeschidem.Dacfiierulnuseafln
directorulcurentsepoateincludeicaleadeacces,caparteanumeluifiierului.Constructorul
returneazoreferinactrefluxuldeieirepentrufiiere.
Secreeazunobiectdescriereapelndconstructorulclasei PrintWriteritransminduio
referin ctre un flux de ieire pentru fiiere. Constructorul returneaz o referin a unui
obiectPrintWriter,care poatefifolositpentruscrierenfiier.Dupcedatelesuntscrisen
fiier,trebuieapelatmetoadaclose()pentruanchidefiierul.
Exemplulurmtorilustreazdeschidereaunuifluxdeieirepentrufiiere,creareaunuiobiect
descrierePrintWriteriscriereadedatenfiier.
ScriereaInFisier.java
import java.io.*;
import java.util.*;
public class ScriereaInFisier

{
{
String studentnume = "bob";
String prenume = "pen";
String grade = "a";
try
{
PrintWriter out = new PrintWriter(new FileOutputStream(
"\\acest_fisier\\student.docx"));
out.print(studentnume);
out.print(prenume);
out.println(grade);
out.close();
}
catch (IOException e)
{
}
}
}
117
ndrumardelaborator
Exemplulncepecudeclarareaiiniializareaatreiiruridecaractere,carevorfiscrisentrun
fiier.ncontinuare,programuldeschideunfluxdeieirepentrufiiereicreazunobiectde
scriere. Fiierul folosit n acest exemplu se numete Student.doc i este stocat n directorul
curent. Programul apeleaz apoi metoda print(), definit n clasa PrintWriter, pentru a
scriedatelenfiierulStudent.doc.Defiecaredatcndesteapelatmetoda print(),isunt
trimisedatelecaretrebuiescrisenfiier.Fiierulestenchisdupscriereaultimuluielementde
date.
Observai c toate instruciunile implicate n deschiderea fluxului de ieire i scrierea n fiier

suntinclusentrunbloc try.Dacapareoproblem,cumarfispaiuinsuficientpedisc,este
aruncatoexcepie,prinsdeunbloccatch.
13.3.2.Citireadintrunfiier
Exist mai multe modaliti de citire a datelor dintrun fiier. Se pot citi octei individuali sau
blocuri de date format dintrun numr specificat de octei. De asemenea, se pot citi, printro
singuroperaie,oliniedeoctei.Olinieesteformatdintroseriedeocteicaresetermincu
un octet corespunztor caracterului linie nou. Acest caracter este similar cu apsarea tastei
ENTER la sfritul uneipropoziii. De obicei, tasta ENTER determin programul sinsereze un
caracter linie nou. Dup citirea liniei programul trebuie s mpart linia n segmente
semnificative, cum ar fi numele i prenumele unui student, folosind metode definite n clasa
String. De asemenea, programul poate s afieze direct pe ecran linia citit. O alt soluie
frecvent folosit la citirea dintrun fiier este s se citeasc datele ca iruri de caractere, nu
octei.
Pentru citirea datelor trebuie s se deschid fiierul. Se creaz un obiect de citire din fiiere,
folosind constructorul clasei FileReader, cruia i se transmite numele (i, eventual, calea)
fiierului.Dacfiierulnuseaflndirectorulcurent,trebuiesseincludnnumeicaleade
acceslafiier.
Operaia de citire a octeilor de pe unitatea de disc se numete suprasarcin (necessary

overhead), adic costul citirii unui fiier. Pentru a reduce suprasarcina, se citete printro
singur operaie un bloc de octei, care se stocheaz ntro zon de memorie numit buffer
(zontampon).Programulciteteapoiocteiidinbuffer,nudirectdepedisc.
Sepoatefolosiaceasttehnicnprogramecrenduncititorcubuffer(bufferedreader),care
creeaz un buffer pentru stocarea datelor citite pe unitatea de disc. Se creeaz un cititor cu
buffer folosind constructorul clasei BufferedReader, cruia i se transmite ca argument o
referin a obiectului FileReader, folosit pentru deschiderea fiierului. Clasa
BufferedReaderdefinetemetodelefolositepentrucitireadatelordinbuffer.
118
Exemplul urmtor ilustreaz crearea obiectelor pentru deschiderea fiierelor i citirea prin
buffer. Acestea sunt apoi folosite pentru a citi date din fisierul creat n exemplu anterior.
Programul deschide fisierul Student.doc, care conine date despre un student. Datele sunt
copiatedinfiiernbuffer.Apoiesteapelatmetoda readLine(),carecitetedateleliniecu
liniedinbufferileatribuieuneivariabiledetipString.
Seobservctoateacesteoperaiisuntexecutatenexpresiantrunciclulwhile.Facemacest
lucru pentru a stabili momentul n care ajungem la sfritul fiierului. Metoda readLine()
returneaz valoarea null atunci cnd ajunge la sfritul fiierului. Cnd se ajunge la sfritul
fiierului,programuliesedinciclulwhileiapeleazmetodaclose(),carenchidefiierul.
CitireaDinFisier.java
import java.util.*;
import java.io.*;
public class CitireaDinFisier

{
{
String linie;
try {
BufferedReader in = new BufferedReader(new FileReader(
"\\acest_fisier\\test2\\student.doc"));
while ((linie = in.readLine()) != null)
{
System.out.println(linie);
}
}
{
}
}
}
13.3.3.Adugareadatelorntrunfiier
Se adaug date ntrun fiier folosind valoarea true pentru al doilea parametru al
constructorului clasei FileOutputStream. Versiunea constructorului folosit n seciunea
Scriereantrunfiieracceptunsingurargument,careestenumelefiierului.nmodprestabilit,
octeiisuntscriidelanceputulfiierului.
Exist o alt versiune a constructorului FileOutputStream, care accept dou argumente.

Primulargumenteste,ipentruacestconstructor,numelefiierului,iaraldoileaargumenteste
119
ndrumardelaborator
valoareabooleana true.nacestcaz,octeiisuntscriilasfritulfiierului(append).Dacnu
exist,fiierulestecreat.
Exemplulurmtorilustreaztehnicadeadugareadatelornfiier.
AdaugareaDatelor.java
import java.io.*;
import java.util.*;
public class AdaugareaDatelor

{
{
String nume = "Mihaila";
String prenume = "Dan";
String grade = "9";
try
{
PrintWriter out = new PrintWriter(new FileOutputStream(
"\\acest_fisier\\test2\\student.doc", true));
out.println(nume);
out.println(prenume);
out.println(grade);
out.close();
}
{
}
}
}
13.3.4.Citireaiscriereunuiobiectntrunfiier
ntrunprogramreal,multedinelementelededatepecarevreislestocaintrunfiiersunt
datemembrealeuneiclase.
Multe atribute ale unei clase sunt stocate n variabile de instan. O variabil de instan
reprezintolocaiedememoriefolositpentrustocareadatelorspecificeuneiinstaneaclasei.
Spresupunemcndefiniiaclaseisuntdefinitedouvariabiledeinstanisuntcreatecinci
obiectealeclasei.Javarezervcinciseturidevariabiledeinstan,independenteunulfade
cellalt.Totui,fiecaredintrecelecinciobiectefoloseteacelaisetdemetodeceleasociate
clasei.
120
Atuncicndsedoretepstrareainstaneiuneiclase,aceastasesalveazntrunfiier.Cndse
faceacestlucru,nfiiersuntsalvatenumaivariabileledeinstan,nuimetodeleclasei.
Etapelescrieriiicitiriiunuiobiectn/dinfiier.
1. trebuie implementat interfaa Serializable n clasa a crei obiecte urmeaz s le

scriei n fiier. Interfaa Serializable permite ca instanele clasei respective s fie
transformatentrunfluxdeocteicarepoatefiscrispediscsautrimispereea.Aceast
operaiesenumeteserializare.Lacitireaobiectului,fluxuldeocteiestedeserializati
estereconstituitinstanaclasei.
2. crearea unei instane a clasei i atribuirea valorii variabilelor de instan. Apoi se
deschidefiierulapelndconstructorulclasei FileOutputStream,cruiaisetransmite
numele fiierului. Operatorul new returneaz o referin a unui obiect
FileOutputStream. Aceast referin este transmis constructorului clasei
ObjectOutputStream, care definete metodele folosite pentru scrierea unui obiect
ntrunfiier.
3. dup crearea unei instane ObjectOutputStream se scrie un obiect n fiier. Pentru
acestlucruseapeleazmetoda writeObject()isetransmiteoreferinaobiectului
dorit a fi scris n fiier. Variabilele statice ale obiectului nu sunt salvate. Ultimul pas
constnapelareametodeiclose(),pentruanchidefiierul.
Citirea unui obiect dintrun fiier este la fel de simpl ca i scrierea unui obiect ntrun fiier.
Totui, n locul clasei ObjectOutputStream se folosete clasa ObjectInputStream, iar n
loculclasei FileOutputStreamsefoloseteclasa FileInputStream.Seciteteunobiectdin
fiier apelnd metoda readObject(), definit n clasa ObjectInputStream. Metoda
readObject() returneaz o referin de tip Object. Aceast referin trebuie convertit la
tipulspecificalclaseiobiectuluicitit.
nexemplulurmtorsalvmnfiierinstanealeclasei Student.Atuncicndcitimoinstan
dinfiieroconvertimlatipul Student.Obiectulreturnatdemetoda readObject()esteapoi
atribuituneireferineaobiectuluirespectiviestefolositcaoricealtobiectdinprogram.
Exemplu definete o clas Student care conine trei variabile de instan, reprezentnd
numele, prenumele i nota studentului. Clasa implementeaz interfaa Serializable, astfel
nctssepoattransformainstaneleclaseinfluxurideoctei.Suntdeclaratetreiinstaneale
clasei,pentrufiecarefiindtransmisedatedeiniializareconstructoruluiclasei.Dateletransmise
suntatribuievariabilelelordeinstan.nacestscopsafolosituntabloudeobiecte,astfelnct
s putem apela la un ciclu for pentru a scrie fiecare obiect n fiier. Folosirea ciclului for
reducenumruldeliniipecaretrebuieslescriemnprogram.
Sedeschidefiierul Student.docapelndconstructorul FileOutputStreamitransmitndui

douargumente:primulestenumelefiierului,iaraldoileaargumentestevaloarealogictrue,
ceeacenseamnacvremsadugamdatenfiier.
121
ndrumardelaborator
Apelm, apoi, metoda writeObject() n primul ciclu for, fiindui transmis o referin a
fiecrei instanei a clasei Student declarat n program. Dup ce este scris n fiier ultima
instanaclasei,fiierulestenchis.
Fiierulestedeschisdinnou,dardeaceastdatpentruacitiobiectelestocatenfiier.nal
doilea ciclu for este apelat metoda readObject(), care citete din fiier fiecare obiect. Se
observcvaloareareturnatdemetoda readObject()esteconvertitlatipul Student.Se
realizeaz acest lucru deoarece metoda readObject() retutneaz o referin pentru clasa
Object, care este prea general pentru a fi folosit n acest program. Clasa Object este
superclasa tuturor obiectelor. Tabloul readStudentInfo este folosit pentru a stoca fiecare
obiectcititdinfiier.
Dup ce ultimul obiect este citit din fiier, fiierul este nchis, apoi sunt afiate pe ecran
variabileledeinstanalefiecruiobiect.
Student.java
import java.io.Serializable;
class Student implements Serializable

{
String studentnume, studentprenume, studentnota;
public Student()
{
}
public Student(String nume, String prenume, String nota)

{
studentnume = nume;
studentprenume = prenume;
studentnota = nota;
}
}
CitScrOb.java
import java.util.*;
import java.io.*;
public class CitScrOb

{
{
Student[] writeStudentInfo = new Student[3];
Student[] readStudentInfo = new Student[3];
122
writeStudentInfo[0] = new Student("Georgescu", "Catalin", "9");

writeStudentInfo[1] = new Student("Diaconu", "Maria", "8");
writeStudentInfo[2] = new Student("Radu", "Marius", "10");
try
{
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream(
"\\acest_fisier\\test1\\studenti.doc", true));
for (int y = 0; y < 3; y++)

out.writeObject(writeStudentInfo[y]);
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream(

"\\acest_fisier\\test1\\studenti.doc"));
for (int y = 0; y < 3; y++)

readStudentInfo[y] = (Student) in.readObject();
in.close();
for (int i = 0; i < 3; i++)

{
System.out.println(readStudentInfo[i].studentnume);
System.out.println(readStudentInfo[i].studentprenume);
System.out.println(readStudentInfo[i].studentnota);
}
}
catch (Exception e)
{
}
}
}
123
ndrumardelaborator
LABORATORUL12
14.Interfeegrafice
Interfaa grafic sau, mai bine zis, interfaa grafic cu utilizatorul (GUI), este un termen cu
neleslargcaresereferlatoatetipuriledecomunicarevizualntreunprogramiutilizatorii
si. Aceasta este o particularizare a interfeei cu utilizatorul (UI), prin care vom nelege
conceptul generic de interaciune ntre un program i utilizatorii si. Aadar, UI se refer nu
numailaceeaceutilizatorulvedepeecrancilatoatemecanismeledecomunicarentreacesta
iprogram.
Limbajul Java pune la dispoziie numeroase clase pentru implementarea diverselor

funcionaliti UI, ns ne vom ocupa n continuare de acelea care permit realizarea unei
interfeegraficecuutilizatorul(GUI).
Pachetul care ofer servicii grafice se numete java.awt, AWT fiind prescurtarea pentru
Abstract Window Toolkit i este pachetul care care a suferit cele mai multe modificari n
trecereadelaoversiuneJDKlaalta.
nprincipiu,creareauneiaplicaiigraficepresupuneurmtoarelelucruri:
Creareauneisuprafeedeafiare(cumarfiofereastr)pecarevorfiaezateobiectele
graficecareservesclacomunicareacuutilizatorul(butoane,controaledeeditare,texte,
etc.);
Crearea i aezarea obiectelor grafice pe suprafaa de afiare n poziiile
corespunztoare;
Definirea unor aciuni care trebuie s se execute n momentul cnd utilizatorul
interacioneazcuobiectelegraficealeaplicaiei;
"Ascultarea" evenimentelor generate de obiecte n momentul interaciunii cu
utilizatoruliexecutareaaciunilorcorespunztoareasacumaufosteledefinite.
Majoritateaobiectelorgraficesuntsubclasealeclasei Component,clasacaredefinetegeneric
o component grafic care poate interaciona cu utilizatorul. Singura excepie o constituie
meniurilecaremotenescclasaMenuComponent.
Aadar,printrocomponentsaucomponentgraficvomnelegencontinuareoriceobiect
care are o reprezentare grafic ce poate fi afiat pe ecran i care poate interaciona cu
utilizatorul.Exempledecomponentesuntferestrele,butoanele,barededefilare,etc.ngeneral,
toate componentele sunt definite de clase proprii ce se gsesc n pachetul java.awt, clasa
Componentfiindsuperclasaabstractatuturoracestorclase.
124
Creareaobiectelorgraficenurealizeazautomatiafiarealorpeecran.Maintieletrebuie
aezate pe o suprafa de afiare, care poate fi o fereastr sau suprafaa unui applet, i vor
deveni vizibile n momentul n care suprafaa pe care sunt afiate va fi vizibil. O astfel de
suprafa pe care se aeaz obiectele grafice reprezint o instan a unei clase obinut prin
extensia clasei Container; din acest motiv suprafeele de afiare vor mai fi numite i
containere. Clasa Container este o subclas special a clasei Component, fiind la rndul ei
superclasatuturorsuprafeelordeafiareJava(ferestre,appleturi,etc).
Aacumamvzut,interfaagraficserveteinteraciuniicuutilizatorul.Decelemaimulteori
programul trebuie s fac o anumit prelucrare n momentul n care utilizatorul a efectuat o
aciune i, prin urmare, obiectele grafice trebuie s genereze evenimente, n funcie de
aciunea pe care au suferito (aciune transmis de la tastatur, mouse, etc.). ncepnd cu
versiunea 1.1 a limbajului Java evenimentele se implementeaz ca obiecte instan ale clasei
AWTEventsaualesubclaselorei.
Un eveniment este produs de o aciune a utilizatorului asupra unui obiect grafic, deci
evenimentele nu trebuie generate de programator. n schimb, ntrun program trebuie
specificat codul care se execut la apariia unui eveniment. Interceptarea evenimentelor se
realizeazprinintermediulunorclasedetiplistener(asculttor,consumatordeevenimente),
clase care sunt definite n pachetul java.awt.event. n Java, orice component poate
"consuma"evenimentelegeneratedeoaltcomponentgrafic.
14.1.Pachetuljavax.swing
Deoarecelucrulcuobiecteledefinitenpachetul java.awtestegreoii,pealocuri,complicat,
Java ofer un pachet care se suprapune peste AWT, oferind un API mai prietenos
programatorului.DenumireaclaselorderivdinceleAWT,croralisaadugatprefixulJ.De
exemplu,clasasButtonadevenitJButton.
ncontinuarevomprezentatreiexemplecarefolosescpachetul javax.swingpentrucrearea
aplicaiilorcuinterfagrafic.
14.2.Oaplicaiecuinterfagraficsimpl
CasetaDialog.java
import javax.swing.*;
public class CasetaDialog

{
{
125
ndrumardelaborator
String str;
/*
* crearea unei casete apeland metoda showMessageDialog ce accepta 4
* argumente: referinta catre fereastra parinte, mesajul ce va fi
* afisat, textul din bara de titlu, constanta pentru indicarea
* tipului casetei acesta metoda este folosita si pentru a afisa
* butonul OK pe care utilizatorul il selecteaza pentru a confirma
* citirea mesajului. atunci cand este apasat mesajul determina
* inchiderea casetei dedialog
*/
JOptionPane.showMessageDialog(null, "Mesaj", "Caseta",

JOptionPane.PLAIN_MESSAGE);
/*
* o caseta de dialog pentru introducerea datelor este afisata prin
* apelarea metodei showInputDialog(). argumentul metodei il
* reprezinta mesajul prin care utilizatorul este invitat sa
* introduca informatiile in caseta de dialog ce vor fi memorate in
* variabila str
*/
str = JOptionPane.showInputDialog("Introduceti Studentul");
System.out.println(str);
System.exit(0);
}
}
Rezultatulrulrii:
1. O caset de dialog prin apelarea metodei showMessageDialog():
2. O caset de dialog pentru introducerea datelor prin apelarea metodei

showInputDialog():
126
3. Continutul irului str (datele introduse n fereastra de dialog) n

consol:
14.3.Creareauneicasetededialog
CasetaDialog.java
public class CasetaDialog

{
{
String str;
/*
* crearea unei casete apeland metoda showMessageDialog ce accepta 4
* argumente: referinta catre fereastra parinte, mesajul ce va fi
* afisat, textul din bara de titlu, constanta pentru indicarea
* tipului casetei acesta metoda este folosita si pentru a afisa
* butonul OK pe care utilizatorul il selecteaza pentru a confirma
* citirea mesajului. atunci cand este apasat mesajul determina
* inchiderea casetei dedialog
*/
JOptionPane.showMessageDialog(null, "Mesaj", "Caseta",

JOptionPane.PLAIN_MESSAGE);
/*
* o caseta de dialog pentru introducerea datelor este afisata prin
* apelarea metodei showInputDialog(). argumentul metodei il
* reprezinta mesajul prin care utilizatorul este invitat sa
* introduca informatiile in caseta de dialog ce vor fi memorate in
* variabila str
*/
str = JOptionPane.showInputDialog("Introduceti Studentul");
System.out.println(str);
System.exit(0);
}
}
127
ndrumardelaborator
Rezultatulrulrii:
1. O caset de dialog prin apelarea metodei showMessageDialog():
2. O caset de dialog pentru introducerea datelor prin apelarea metodei

showInputDialog():
3. Continutul irului str (datele introduse n fereastra de dialog) n

consol:
14.4.Concatenareaadouiruridecaractere
Fereastra.java
import java.awt.*;
import java.awt.event.*;
class Fereastra extends JFrame

{
JPanel contentPane; // container
JLabel jl_first_text = new JLabel(); // control static de tip text
JLabel jl_second_text = new JLabel();
JTextField jtf_editare_text1 = new JTextField(); // control de editare

JTextField jtf_editare_text2 = new JTextField();
JTextField jtf_siruri_concatenate = new JTextField();
JTextField jtf_lungime_sir = new JTextField();
128
JButton jb_concateneaza = new JButton(); // controale de tip buton
// JButton jb_reseteaza = new JButton(); (de adaugat in vers. 2)
Fereastra()
{
initializare();
}
public void initializare()

{
// stabileste titlul ferestrei
setTitle("Fereastra Test");
// se preia in obiectul "contentPane" containerul principal

// ferestrei
contentPane = (JPanel) getContentPane();
// stabilim tipul de container

contentPane.setLayout(null);
// se creeaza componentele ferestrei (obiecte)

jl_first_text.setText("Primul text");
jl_first_text.setBounds(10, 10, 130, 22);
jl_first_text.setFont(new java.awt.Font("SansSerif",
Font.PLAIN, 12));
jl_first_text.setForeground(Color.black);
jl_second_text.setText("Al doilea text");

jl_second_text.setBounds(10, 40, 130, 22);
jl_second_text.setFont(new java.awt.Font("SansSerif",
Font.PLAIN, 12));
jl_second_text.setForeground(Color.black);
jtf_editare_text1.setText("");
jtf_editare_text1.setBounds(130, 10, 240, 22);
jtf_editare_text1.setFont(new java.awt.Font("SansSerif",
Font.ITALIC, 12));
jtf_editare_text1.setForeground(Color.black);
jtf_editare_text2.setBounds(130, 40, 240, 22);
jtf_editare_text2.setFont(new java.awt.Font("SansSerif",
Font.PLAIN, 12));
jtf_editare_text2.setForeground(Color.black);
jb_concateneaza.setText("Concateneaza siruri");
jb_concateneaza.setBounds(150, 70, 200, 22);
jb_concateneaza.setFont(new java.awt.Font("SansSerif",
Font.BOLD, 12));
129
ndrumardelaborator
jb_concateneaza.setForeground(Color.red);
jb_concateneaza.addActionListener(
new java.awt.event.ActionListener() {
// metoda apelata automat de fiecre data cand utilizatorul executa
// un clic pe un buton
public void actionPerformed(ActionEvent e)
{
concateneazaSiruri();
}
});
jtf_siruri_concatenate.setText("");
jtf_siruri_concatenate.setBounds(130, 100, 240, 22);
jtf_siruri_concatenate.setFont(new java.awt.Font("SansSerif",
Font.PLAIN, 12));
jtf_siruri_concatenate.setForeground(Color.black);
jtf_lungime_sir.setText("");
jtf_lungime_sir.setBounds(380, 100, 20, 22);
jtf_lungime_sir.setFont(new java.awt.Font("SansSerif",
Font.PLAIN, 12));
jtf_lungime_sir.setForeground(Color.blue);
// adaugam componentele in conatinerul principal

contentPane.add(jl_first_text, null);
contentPane.add(jl_second_text, null);
contentPane.add(jtf_editare_text1, null);
contentPane.add(jtf_editare_text2, null);
contentPane.add(jb_concateneaza, null);
contentPane.add(jtf_siruri_concatenate, null);
contentPane.add(jtf_lungime_sir, null);
}
public void concateneazaSiruri()

{
// concatenez continutul celor 2 controale de editare
String noulSir = jtf_editare_text1.getText() + " "
+ jtf_editare_text2.getText();
// setez valoarea in control de editare corespunzator

jtf_siruri_concatenate.setText(noulSir);
// setez lungimea sirului(ca text) in ultimul control

jtf_lungime_sir.setText(String.valueOf(noulSir.length()));
// resetez valorile din cele 2 controale

}
}
130
Main.java
class Main
{
{
// se creeaza un obiect de tip Fereastra
Fereastra fereastra = new Fereastra();
// stabileste pozitia ferestrei pe ecran (coltul stanga-sus)

fereastra.setLocation(50, 50);
// stabileste dimensiunea ferestrei

fereastra.setSize(450, 250);
// se face vizibila fereastra creata

fereastra.setVisible(true);
}
}
Rezultatulrulrii:

131
ndrumardelaborator
Completaiaplicaiaprinadugareaunuibutonderesetareacasetelor.

132

PCLP2 - Indrumar de Laborator PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

PCLP2 - Indrumar de Laborator PDF

Încărcat de

Drepturi de autor:

Formate disponibile

DominicMirceaKRISTLY AncaVULPE

javac is not recognized as an internal or external command, operable program or

Crearea i deschiderea n workbench a noului proiect se realizeaz prin apsarea butonului

Se recomand respectarea urmtoarei convenii de notare: numele claselor ncep

System.out.println(Hello World din Java!);

Deoarece instruciunea System.out.println() este foarte uzitat, editorul

Tipul Octeialocai Acoperirea

// numrul 10 scris n hexazecimal

int example_hexa = 0xA;

// numrul 8 scris n sistemul octal (folosirea acestei baze de numeraie

int example_octa = 010;

Numerele reale sunt reprezentate n limbajul Java ca numere cu semn (reprezentare n

nmodimplicitliteraliinumererealesuntreprezentaicavalori double.Literaliidetip float

Tipul Octeialocai Acoperirea

// variabila ch va contine caracterul avand codul 1111

Secvenaescape ValoareaUnicode Denumire

byte short int long char float double

Sintaxutilizat: id_tip id_var1[, id_var2 [, ...]];

int v1, v2;

Declararea variabilelor se poate face oriunde pe parcursul programului. De asemenea,

Referitor la numele variabilelor se recomand denumirea lor n concordan cu semnificaia

final double PI = 3.14159;

public class VariabileOperatori

Scanner tastatura = new Scanner(System.in);

String nume = tastatura.nextLine();

public class IntrariIesiri

public class EcuatiaDeGradulDoi

System.out.print("coeficientul lui x^2:");

System.out.print("coeficientul lui x:");

System.out.println("x1= " + (-b / (2 * a)) + "+ i*" +

1. n cazul n care n clauza case a crei constant se potrivete cu valoarea

for (int i=0 ; i<=2 ; i++)

i=0 j=0 j=1 j=2

public class ExempluFor

System.out.print("Introduceti un divizor: ");

// declararea unei variabile de tip primitiv (int)

System.out.println("Suma numerelor impare pana la " + a +

// numere prime varianta 1

for (int i = 1; i <= a; i++)

for (int j = 2; j < i; j++)

// afisarea numarului daca este prim

// numere prime varianta 2

for (int i = 1; i <= a; i++)

for (int j = 2; j <= i/2; j++)

for (int i = 1; i <= a; i++)

public class ExempluWhile

System.out.print("Cati bani doresti sa retragi? ");

System.out.print("Cu cati bani vrei sa contribui in fiecare an? ");

System.out.print("Introduceti dobanda %: ");

// valoarea rambursata in fiecare an

if ((retragere - returnat) < (x))

int l = (int) luni % 12;

corpul ciclului, cuvntul cheie while, expresia condiional, ncadrat de paranteze, i un

System.out.println("Dupa continue i="+i);

Inainte de continue i=2

nmomentulncarecondiiadin ifestendeplinit(i=4)seexecutinstruciunea continue.

public class ExDoWhileSwitch

// citirea optiunii utilizatorului

System.out.println("Optiunea dumneavoastra nu este definita.");

Sintaxutilizat: <tip_elemente> <identificator_tablou>[];

int[] note = new int[6];

Nu se folosete operatorul new pentru declararea unui tablou dac acesta se

int note[][] = new int [3][2];