Indrumar de Laborator Java

DominicMirceaKRISTLY AncaVULPE
ndrumardelaborator |Braov,2009
LIMBAJULDEPROGRAMAREJAVA
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
ndrumardelaborator
ii
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
iii
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
ndrumardelaborator
iv
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
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.
Figura 2 prezint codul surs al unui program Java care afieaz pe ecran textul Hello World
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
Dac programul nu a fost compilat cu succes, n fereastra sistem pot apare diferite mesaje de
eroare,precum:
javac is not recognized as an internal or external command, operable program or
batchfile.
Cauzeposibile:
1. nuesteinstalatpachetulJDK.
o Soluie:instalareapachetuluiJDK;
2. esteinstalatpachetulJDK,darcaleadirectoruluibinnuafostinclusnvariabila
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:invalid flag: dacapareacestmesaj,urmatdeolistlungdecuvintecarencep
cu-cauzeleposibilesunt:
1. compilatorulnupoategsifiierulsursJava.Sevaafiadirectorulcurent.
2. scriereagreitanumeluifiieruluilacompilare.
3. omitereaextensieifiierului(.java).
Hellojava:6:;expected
Cnd o eroare conine cuvntul expected urmat de un fragment de program nseamn
c fragmentul respectiv conine o eroare de sintax. n acest exemplu,linia 6 estecea
careagenerateroarea.

1.3.Lansareanexecuieaprogramului
Pentru a putea lansa n execuie un program Java, calculatorul gazd trebuie s aib instalat
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
recent versiune, Eclipse Ganymede, poate fi descrcat de pe siteul oficial www.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, n funcie de limbajul utilizat n proiectul deschis. n capturile de ecran prezentate n
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
funciile pe care le ndeplinesc acele clase n proiect (lucrul cu fiiere, accesul la baze de date,
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
10
Fig.10.Creareauneiclase
Dac se dorete ca clasa creat s conin metoda main(), atunci se bifeaz opiunea public
static void main(String[] args) din seciunea Which method stubs would you like to create?. 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

Dup apsarea butonului Finish, este deschis automat fiierul ce conine declaraia noii clase,
aacumsevedenfigura11.
11
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
ndrumardelaborator
12
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
13
3.StructuraunuiprogramJava
3.1.Definiiaclasei
3.2.Definiiametodelor
3.3.Instruciuni

ndrumardelaborator
14

15
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
Aceste tipuri sunt reprezentate n memorie ca numere cu semn (reprezentare n complement
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.
ndrumardelaborator
16
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
complement fa de 2, virgul mobil simpl sau dubl precizie). Limbajul Java nu ofer tipuri
realefrsemn.
Exist dou tipuri de numere reale reprezentate n virgul mobil: float (simpl precizie) i
double (dubl precizie). Numerele iraionale (cum ar fi sau2) sunt trunchiate, putnduse
lucradoarcuoaproximarealor.
Este recomandat folosirea tipului float numai cnd viteza la care trebuie s ruleze aplicaia
trebuiesfiefoartemare(saumemoriafolositdeaceastatrebuiesfiefoartemic).
n mod implicit literalii numere reale sunt reprezentai ca valori double. Literalii de tip 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.
17
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.

ndrumardelaborator
18
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.
Mai concret, o variabil este un spaiu de memorie destinat stocrii unei valori ntrun format
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;

19
Astfel, se poate spune, pe scurt, c definirea unei variabile reprezint declararea ei, la care se
adaugoperaiadeiniializare.

Declararea variabilelor se poate face oriunde pe parcursul programului. De asemenea,
variabilele se pot redeclara, cu restricia ca redeclararea s nu se fac n acelai bloc cu prima
declaraie(decisnuseaflenacelaidomeniudedeclaraiescope).
Referitor la numele variabilelor se recomand denumirea lor n concordan cu semnificaia
datelor pe care le reprezint. Aceast msur confer o claritate sporit sursei i minimizeaz
timpulnecesarefecturiiunorcorecturisaumodificri.
De asemenea, numele unei variabile nu poate ncepe cu o cifr; ele pot ncepe cu orice liter
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
ndrumardelaborator
20
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");
21
// 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);

n continuare se pot utiliza metodele definite n clasa Scanner pentru preluarea datelor de la
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.
ndrumardelaborator
22
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();
}
}

23
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");

ndrumardelaborator
24
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>;

25

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.

ndrumardelaborator
26
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");
27
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.
ndrumardelaborator
28
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

expresieidinswitchicomandabrakenuestefolosit,atunciseexecuti
instruciunile din clauzele case urmtoare, pn cnd ntlnete primul
breaksausetermininstruciunea switch.
2. Oclauzelseestefolositntroinstruciuneifpentruadefiniinstruciunile
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.
29
6.2.Instruciuniiterative
Acest tip de instruciuni cer mainii virtuale Java s execute una sau mai multe instruciuni, n
modrepetat,atttimpctestendeplinitocondiie.
nJavaexist3tipurideinstruciuniiterative:
for:instruciuneiterativcutestiniial,cunumrcunoscutdepai;
while:instruciuneiterativcutestiniial,cunumrnecunoscutdepai;
dowhile:instruciuneiterativcutestfinal,cunumrnecunoscutdepai.
6.2.1.Instruciuneafor

Instruciunea for se utilizeaz atunci cnd se cunoate sau se poate antecalcula numrul de
repetriainstruciunii/bloculuideinstruciuniicorpulinstruciuniifor.
Formatgeneral:

for ([<initializare>];[<conditie_continuare>];[<modificare_stare>])
[<instructiune>];

Schemlogic:

Exemplu:

for (int i=0 ; i<=2 ; i++)
{
System.out.println("i="+i);
}

ndrumardelaborator
30
Moduldelucru:
Ciclu Instruciune/operaie
4
i=0
test0<=2(A)
afiarei=0
i=1
test1<=2(A)
afiarei=1
i=2
test2<=2(A)
afiarei=2
i=3
test3<=2(F)setermininstruciuneafor

Expresiideiniializarealternative:

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

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

1. Instruciuneaforare,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.
31
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;
ndrumardelaborator
32
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++)
{
33
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)
}
}
}
}

ndrumardelaborator
34

35
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++;
}

Atunci cnd ntlnete un ciclu while n program, Java evalueaz expresia condiional. 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.
ndrumardelaborator
36
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;

37
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 de acolade de deschidere i nchidere, una sau mai multe instruciuni din
ndrumardelaborator
38
corpul ciclului, cuvntul cheie while, expresia condiional, ncadrat de paranteze, i un

caracterpunctivirgul.
Exemplu:

int i=0;
do {
i++;
} while(i<=2);

Instruciuniledintruncicludo..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.
39
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

n momentul n care condiia din if este ndeplinit (i=4) se execut instruciunea continue.
Dupacestapelseignortoateinstruciunileaflatedupinstruciuneacontinueisetrecela
urmtoareaiteraie.
6.3.3.Instruciuneareturn
Instruciunea return este folosit n metode pentru a transfera napoi controlul execuiei la
instruciunea care a apelat metoda. Instruciunea poate returna o valoare, dar acest lucru nu
esteobligatoriu.
ndrumardelaborator
40
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:
41
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:
ndrumardelaborator
42
System.out.println("Optiunea dumneavoastra nu este definita.");

}

} while (c != 6);
}
}

43
LABORATORUL5
7.Tablouri
Rezervarea memoriei pentru stocarea unei date este o operaie foarte simpl: se folosete un
tipdedateiunnumepentruadeclaraovariabil.
Spresupunemctrebuierezervatmemoriepentruastoca100deelementedeunanumittip.
La prima vedere nu pare complicat: trebuie declarate 100 de variabile. Acest lucru presupune
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.
Un index este un ntreg cuprins ntre zero i numrul maxim de elemente ale tabloului, 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.
ndrumardelaborator
44
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];

OperatorulnewceremainiivirtualeJavasrezervememoriepentrustocareaa6valorintregi
prinnew int[6].
Operatorul new returneaz adresa primului element. Celelalte elemente sunt dispuse, n
memorie,unalngcealalt,secvenial,dupprimulelement.
Adresareturnatestememoratnvariabilareferin.
1.Cndsedeclaruntablousespecificntotdeaunanumruldeelemente.
2. Primul index al tabloului este 0, i nu 1, iar ultimul element al tabloului are indexul
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.
45
7.2.TablourimultidimensionaleMatrice
Tablourilepotaveamaimultedimensiuni.Acesteasuntnumitetablourimultidimensionalesau
matrice.
7.2.1.Creareaunuitabloumultidimensional
Declarareauneimatricesepoatefacefolosindoperatorulnew,ntrunmodasemntorcucel
folositpentrutablouriunidimensionale.Exempluurmtorilustreazaceasttehnic.
int note[][] = new int [3][2];

Fiecareperechedeparantezedreptedindeclarareauneimatricereprezintodimensiune.
I
n
d
e
x
u
l

d
i
n

s
t
n
g
a
Fig.14.Elementeletablourilormultidimensionale

7.2.2.Atribuireavalorilorctreelementelematricei
Un element al unui tablou este folosit ntro expresie la fel ca i o variabil. Singura diferen
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];

ndrumardelaborator
46
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.
Dou tablouri sunt transmise ca parametrii metodei equals(), care stabilete dac tablourile
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;
47

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:
Prima versiune are nevoie de dou argumente: numele tabloului i valoarea care va fi
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);
ndrumardelaborator
48

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.
49
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);
ndrumardelaborator
50

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);

51
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]);
}
}

ndrumardelaborator
52
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]);

}
}

53
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
ndrumardelaborator
54
// 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();
}
}
}

55
LABORATORUL6
8.iruridecaractere
iruriledecaracterepotfireprezentatedetipurileStringiStringBuffer.
Dac se dorete ca un ir de caractere s rmn constant, atunci se folosete tipul String.
Dacsedoretemodificareairului,atuncisevautilizatipulStringBuffer,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;

ndrumardelaborator
56
// 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;


57
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");
}
ndrumardelaborator
58

// 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
+ "\"");

59
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\"");
}
}

ndrumardelaborator
60
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");
61
// 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);
}
}

ndrumardelaborator
62

63
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
i propriul cod executabil. Un obiect este o instan a unei clase, adic este construit pe baza
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.
Polimorfismul reprezint mecanismul care permite accesarea proprietilor i metodelor unui
obiectdeunanumittipprinintermediulunortipuridedatedincareacestaafostobinutprin
derivare.
9.2.Definiiauneiclase
Ceamaisimpldefiniieauneiclase,nJava,esteformatdintreicomponente:
Fig.15.Componenteleesenialealeuneiclase
ndrumardelaborator
64
1.Princonvenie,numeleclaselorJavatrebuiesnceapculitermare.Dacnumele
coninemaimuliatomilexicali,fiecaredintreeitrebuiesnceapculitermare.De
exemplu:
class ClasaAceastaRespectaConventiaDeNotare
{

}

2.Estefoarteindicatcafiecareclassfiescrisnpropriulfiier.Numelefiierului,n
modobligatoriu,trebuiesaibexactacelainumecucelalclaseiconinute.

Corpulclaseiconinedeclaraiiledeproprietiimetode.
9.2.1.Modificatorideacces
Programarea orientat obiect impune existena unui mecanism de control asupra accesului la
clase i proprietile i metodele unui obiect. n Java, acest mecanism este implementat prin
modificatorideacces.
Exist 4 modificatori de acces: private, protected, public i implicit (atunci cnd nici unul
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).
65
Metodelepurtndacestmodificatornumaipotfisupradefinitensubclase.
ncazulclaselor,finalprecizeazcaceaclasnumaipoatefiderivat(nuaremotenitori).
9.2.2.2.Modificatorulstatic
Acestmodificatorpoatefiutilizatnumaipentruproprietiimetode.
Proprietile i metodele declarate cu modificatorul static poart denumire de proprieti,
respectivmetodede clas.Dacoproprietatesauometodnuconinemodificatorulstatic
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
O metod este o parte a unui program care conine logica pentru executarea unei sarcini. 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.
ndrumardelaborator
66
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
instruciunea care apeleaz metoda. n cadrul unei metode, numele parametrului se folosete
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.
67
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.
Din punct de vedere tehnic, constructorul este apelat nainte ca operatorul new si termine
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 unui constructor care are o list de parametri. Acesta se 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
dorete un constructor fr argumente dup ce sa definit unul cu argumente trebuie
creatconstructorulfrargumentenmodexplicit.
ndrumardelaborator
68
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:
OperatorulnewceremainiiJavasrezerveunblocdememoriepentruinstan.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).
Pentru a obine accesul la un membru al unei clase, se folosete numele referinei, urmat de
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
este iniializat cu numrul de identificare al unui student, de ctre constructor, la declararea
instanei.Instanaesteapoifolositpentruaapelametodaprint(),careafieaznumelede
identificarealstudentului.
69
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.
O clas poate avea mai multe metode cu acelai nume, dar semntura fiecrei metode s fie
unicndefiniiaclasei.
Atunci cnd ntro clas exist dou metode cu acelai nume se spune c a doua metod
suprancarcprimametod.
1.Doumetodealeuneiclasenupotaveaaceeaisemntur.
2.Metodeadouclasediferitepotaveaaceeaisemntur.
ndrumardelaborator
70
Aceastideeesteilustratnurmtorulexemplu,ncareexistdoumetodenumiteprint().
Prima versiune nu are o list de argumente i afieaz un mesaj de ntmpinare prestabilit de
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.
71
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.
ndrumardelaborator
72
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;
}

73
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");
}
}
ndrumardelaborator
74
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;
}

75
// 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
Definiia unei clase poate conine definiia unei alte clase. Acestea se numesc clase imbricate.
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.
O clasa imbricat nestatic este denumit clas intern. Ea este definit n interiorul unei alte
clasedenumitclasextern.Clasainternareaccesdirectlamembriiclaseiexternefrsse
declareoinstanaclaseiexterne.
ndrumardelaborator
76
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();
}

77
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();

ndrumardelaborator
78
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
{
{

79
// definirea unui obiect de tip Figura

Figura extern = new Figura();

/*
* apelarea metodei metoda() ce apartine clasei Figura prin
* intermediul obiectului extern
*/
extern.metoda();
}
}

ndrumardelaborator
80

81
LABORATORUL8
10.Motenirea
Proprietiledeinstanimetodelecomunemaimultorobiectesedeclarntrosingurclas
(ex.clasaA).Pentruobiectelenruditesepoatedeclaraonouclas(ex.clasaB)ceconineatt
membriiclaseiActimembriiparticulariclaseiB.
Esteinutilssedeclareidefineascaceeaimembriatttimpctexistosoluiemaibuni
anumemotenirea.
O clasa (B copil) care motenete o alt clas (A - printe) are acces la toi membrii clasei
printe,caicumacetiaarfifostdeclaraiidefiniipentruclasacopil.
Regula pentru a stabili dac motenirea este potrivit pentru un anumit program se numete
esteuniimpunecaunobiectsaiborelaiecuunaltobiectnaintedealmoteni.
Conform regulii esteun, punem urmtoarea ntrebare: obiectul A este un obiect B?. 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.
Aplicnd regula esteun obiectului care reprezint studentul masterand, punem urmtoarea
ntrebare: Studentul masterand este un student?. Rspunsul este afirmativ deci clasa
StudentMasterandpoatesmoteneascclasaStudent.
AplicndaceeairegulclaseiStudentNelicentiat(Studentulneliceniatesteunstudent?)
observmcStudentNelicentiatpoatemoteniclasaStudent.
Oclasmoteneteoaltclasfolosindcuvntulcheieextendsndefiniiaclasei.
ndrumardelaborator
82
Clasa motenit este numit superclasa (clasa printe), iar clasa care motenete se numete
subclasa(clasacopil).
Motenirea:

public class A
{

}

class B extends A
{

}

10.1.Accesullamembriiuneiclasemotenite
Accesullamembriiuneiclasesefacenfunciedespecificatoriideaccesfolosii.
Unmembrudeclaratcapublicesteaccesibilpentruoricealtmembru,dinoricealtclas.Un
membrudeclaratcaprivateesteaccesibilpentruoricemetodmembrdinpropriaclas.Un
membrudeclaratcaprotectedesteaccesibilpentruoricemetodmembrdinpropriaclas
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
{
}

83
Demonstratie.java

class Demonstratie
{
{
StudentMasterand ob = new StudentMasterand();
ob.afisare();
}
}

nexempluldemaisus,clasaStudent,pelngconstructor,aredoimembri:oproprietatede
instan numit studentID i o metod membr numit afisare() ce afieaz pe ecran
valoarea proprietii studentID. Constructorul este folosit pentru iniializarea proprietii de
instan.
ClasaStudentMasterandnuareniciunmembru,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.
Aceastideeesteilustratdeinstruciuniledinmetodamain()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
publici i protejai ai superclasei, dar superclasa nu are acces la membrii publici i protejai ai
subclaselor.
10.2.Apelareaconstructorilor
Atunci cnd o subclas motenete o superclas, la instanierea subclasei sunt implicai cel
puindoiconstructori.
Atunci cnd se declara o instan a subclasei, Java apeleaz att constructorul subclasei ct i
celalsuperclasei.
ndrumardelaborator
84
10.2.1.Folosireacuvntuluicheiesuper
Cuvntul cheie super este utilizat pentru referirea la membrii unei superclase n metodele
uneisubclase.
Cuvntul cheie super se folosete la fel cum se folosete o referin a unei instane pentru a
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();
}

}

85
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,iaraldoileafolosete pentruiniializareovaloareprimitcaparametru.Sespune
caldoileaconstructorsuprancarcprimulconstructor.
Constructorul clasei StudentMasterand conine o singur instruciune ce folosete cuvntul
cheiesuperpentruaapelaconstructorulsuprancrcatalclaseiStudent.Metodaafisare()
dinclasaStudentMasterandconineosingurinstruciunecefolosetecuvntulcheiesuper
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";
}
ndrumardelaborator
86

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
{
{
87
StudentMasterand a = new StudentMasterand();

a.metoda();
}
}

nexemplulanteriorsaudefinittreiclase:Persoana,Student,StudentMasterand. Fiecare
clas trece prin testul este un (studentul este o persoan, iar un student masterand este un
student).Aceastanseamncsepotlegaceletreiclasentrorelaie,folosindmotenirea.
Motenirea pe mai multe niveluri permite unei subclase s moteneasc o singur superclas.
TotuinaplicaiesedoretecaStudentMasterand smoteneascattclasaStudent,cti
clasa Persoana. Se poate ocoli restricia impus de motenirea simpl crend mai nti o
relaiedemotenirentreclasaPersoana iclasaStudent. ClasaStudentareacceslatoi
membriiprotejaiipubliciaiclaseiPersoana.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
protejaiaiclaseiPersoana,deoarececlasaStudent amotenitdejaaccesullaaceimembrii
prinmotenireaclaseiPersoana.
Acestexemplu creeazo motenire pe maimulte niveluri.Primul nivel este format din clasele
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).
ndrumardelaborator
88
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;

89
/*
* 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);
ndrumardelaborator
90

// 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
Cuvntulcheiefinalaredouautilizrinmotenire.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.");
}
}

91
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, aceste instruciuni depind de surse din afara programului, cum ar fi date introduse de
utilizatorulprogramuluisauprelucrricarearputeacauzaerorideexecuie.
nlocsseverificedateleprovenitedinsurseexternesaudinalteprelucrrisemonitorizeaz
aceste instruciuni i se arunc o excepie dac apare o eroare de execuie. De asemenea, se
include n program instruciuni care sunt executate dac este aruncat o excepie. Aceast
procedursenumeteprindereauneiexcepii.
Instruciunilecetrebuiescmonitorizatetrebuiencadratentrunbloctry.
try
{
<instructiuni>;
}

Instruciunileexecutateatuncicndapareoexcepiesuntplasatentrunbloccatch.
ndrumardelaborator
92
catch (<tip_exceptie> <id_var_exceptie>)

{
<instructiuni>;
}

Mai exist o seciune finally ce conine instruciuni care se execut indiferent dac a
aprutoexcepiesaunu.Deobicei,nbloculfinallyseplaseazinstruciunicareelibereaz
resurselerezervatedeprogram.
finally
{
<instructiuni>;
}

Fiecruibloctrytrebuiesicorespundcelpuinunbloccatchsauunblocfinally.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;

93
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.
Cnd se ncearc o mprire la zero, instruciunea n cauz arunc o excepie de mprire la
zero,careesteprinsdevariabilae.
Oseriedeinstruciunipotgeneramaimultetipurideerorideexecuie.Prinurmaresefolosesc
blocuricatchmultiplepentruainterceptafiecaretipdeexcepie.
Blocurilecatchmultipletrebuiescplasateimediatdupblocultryncarearputeafiaruncat
excepia.Deasemenea,blocurilecatchtrebuiesfieplasateunuldupaltul.
Atunci cnd apare o excepie, Java o arunc ctre blocurile catch care urmeaz dup blocul
try,nordineancareaparacesteanprogram.Dacexistdoublocuricatchiprimulbloc
prindeexcepia,aceastanumaiajungelaaldoileabloccatch,deoareceestetratatnprimul
bloc.
ndrumardelaborator
94
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];
}

95
{
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];

}
{
}
{
}
}
}
ndrumardelaborator
96
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

97
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
internsenumetebloctryimbricat.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 try extern. Dac nici n acest fel excepia nu este tratat atunci excepia este tratat
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);
}
}
}

ndrumardelaborator
98
Rezultatulrulrii:

S-a depasit indexul!!!!
Eroare:java.lang.ArrayIndexOutOfBoundsException: 3

11.2.Lucrulcuexcepiineinterceptate
Deintimpulexecuieiprogramuluipotapreafoartemulteexcepii,nuestenevoiessescrie
cteunbloccatchastfelnctsfieprinsetoate.Oriceexcepiepentrucarenuexistunbloc
catchesteinterceptatdebloculcatchimplicitdinJava,numitprocedurimplicitdetratare
aexcepiilor(defaulthandler).
Ori de cte ori prinde o excepie, procedura implicit afieaz dou tipuri de informaii: un ir
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.
99
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:maintiesteapelatfunciamain()
a programului Demo.java, apoi n linia 4 a fost apelat metoda metoda(). Linia 9 a
programului, care face parte din definiia metodei metoda(), este punctul n care sa ncheiat
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.
Sespecificexcepiilelansatefolosindcuvntulcheiethrowsnantetulmetodei,duplistade
parametri.Dacsunmaimultetipurideexcepii,elevorfiseparateprinvirgule.
Exemplulurmtorilustreazspecificareaexcepilorcaresuntaruncate,darnuiinterceptarea
dectremetod.
Metoda myMethod() poate arunca dou excepii: ArithmeticException i
ArrayIndexOutOfBoundsException. Totui metoda myMethod() nu prinde nici una dintre
aceste excepii. Metoda main() prinde excepia ArithmeticException, dar las excepia
ArrayIndexOutOfBoundsExceptionnseamaproceduriidetratareimplicitdinJava.
ndrumardelaborator
100
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
trebuie s fie incluse n lista de excepii aruncate de o metod; dac metoda respectiv poate
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.
101
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.
ndrumardelaborator
102
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;
103
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");
}
ndrumardelaborator
104
{
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.");
}

105

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);
}

ndrumardelaborator
106
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.");
}
}
}
}

107
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);
ndrumardelaborator
108
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;
}

109
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();
}
}

ndrumardelaborator
110
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]);
}

111

{
Instrument[] orchestra = new Instrument[2];
int i = 0;
orchestra[i++] = new Pian();
orchestra[i++] = new Vioara();
playAll(orchestra);
}
}

ndrumardelaborator
112
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,
113
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.

Dup ce programul are la dispoziie o cale de acces la un director sau un fiier, pot fi apelate
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.
ndrumardelaborator
114
canRead()
Returneazvaloareabooleantruedacdirectorul
saufiierularepermisiunedecitire;altfelreturneaz
valoareabooleanfalse.
canWrite()
saufiierularepermisiunedescriere;altfelreturneaz
valoareabooleanfalse.
exists()
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
115
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
recomandatsseapelezemetodaisDirectory()pentruaverificadacobiectulestesaunu
director,naintedeapelareametodei.
Exemplul urmtor ilustreaz folosirea metodelor list() i isDirectory() pentru obinerea
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();
ndrumardelaborator
116
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.
117
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.
Se creeaz un obiect de scriere apelnd constructorul clasei PrintWriter i transmindui o
referin ctre un flux de ieire pentru fiiere. Constructorul returneaz o referin a unui
obiectPrintWriter,care poatefifolositpentruscrierenfiier.Dupcedatelesuntscrisen
fiier,trebuieapelatmetoadaclose()pentruanchidefiierul.
Exemplul urmtor ilustreaz deschiderea unui flux de ieire pentru fiiere, crearea unui obiect
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)
{
}
}
}

ndrumardelaborator
118
Exemplulncepecudeclarareaiiniializareaatreiiruridecaractere,carevorfiscrisentrun
fiier. n continuare, programul deschide un flux de ieire pentru fiiere i creaz un obiect de
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
scrie datele n fiierul Student.doc. De fiecare dat cnd este apelat metoda print(), i sunt
trimisedatelecaretrebuiescrisenfiier.Fiierulestenchisdupscriereaultimuluielementde
date.
Observai c toate instruciunile implicate n deschiderea fluxului de ieire i scrierea n fiier
suntinclusentrunbloctry.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 unei propoziii. De obicei, tasta ENTER determin programul s insereze 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.
Se poate folosi aceast tehnic n programe crend un cititor cu buffer (buffered reader), 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.
119
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
copiate din fiier n buffer. Apoi este apelat metoda readLine(), care citete datele linie cu
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
ndrumardelaborator
120
valoarea booleana true. n acest caz, octeii sunt scrii lasfritul fiierului (append). Dac nu
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
obiecte aleclasei. Javarezerv cinci seturi de variabile de instan, independenteunul fa de
cellalt.Totui,fiecaredintrecelecinciobiectefoloseteacelaisetdemetodeceleasociate
clasei.
121
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
deschidefiierulapelndconstructorulclaseiFileOutputStream,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
acestlucruseapeleazmetodawriteObject()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
loculclaseiFileOutputStreamsefoloseteclasaFileInputStream.Seciteteunobiectdin
fiier apelnd metoda readObject(), definit n clasa ObjectInputStream. Metoda
readObject() returneaz o referin de tip Object. Aceast referin trebuie convertit la
tipulspecificalclaseiobiectuluicitit.
n exemplul urmtor salvm n fiier instane ale clasei Student. Atunci cnd citim o instan
dinfiieroconvertimlatipulStudent.ObiectulreturnatdemetodareadObject()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.
SedeschidefiierulStudent.docapelndconstructorulFileOutputStreamitransmitndui
douargumente:primulestenumelefiierului,iaraldoileaargumentestevaloarealogictrue,
ceeacenseamnacvremsadugamdatenfiier.
ndrumardelaborator
122
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.
Fiierul este deschis din nou, dar de aceast dat pentru a citi obiectele stocate n fiier. n al
doilea ciclu for este apelat metoda readObject(), care citete din fiier fiecare obiect. Se
observ c valoarea returnat de metoda readObject() este convertit la tipul 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];

123
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)
{
}
}
}

ndrumardelaborator
124
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.
MajoritateaobiectelorgraficesuntsubclasealeclaseiComponent,clasacaredefinetegeneric
o component grafic care poate interaciona cu utilizatorul. Singura excepie o constituie
meniurilecaremotenescclasaMenuComponent.
Aadar, printro component sau component grafic vom nelege n continuare orice obiect
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.
125
Crearea obiectelor grafice nu realizeaz automat i afiarea lor pe ecran. Mai nti ele trebuie
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).
Aa cum am vzut, interfaa graficservete interaciunii cu utilizatorul. De cele mai multe ori
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
realizeaz prin intermediul unor clase de tip listener (asculttor, consumator de evenimente),
clase care sunt definite n pachetul java.awt.event. n Java, orice component poate
"consuma"evenimentelegeneratedeoaltcomponentgrafic.
14.1.Pachetuljavax.swing
Deoarecelucrulcuobiecteledefinitenpachetuljava.awtestegreoii,pealocuri,complicat,
Java ofer un pachet care se suprapune peste AWT, oferind un API mai prietenos
programatorului.DenumireaclaselorderivdinceleAWT,croralisaadugatprefixulJ.De
exemplu,clasasButtonadevenitJButton.
n continuare vom prezenta trei exemple care folosesc pachetul javax.swing pentru crearea
aplicaiilorcuinterfagrafic.
14.2.Oaplicaiecuinterfagraficsimpl
CasetaDialog.java

import javax.swing.*;

public class CasetaDialog
{
{

ndrumardelaborator
126
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():

127

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);
}
}

ndrumardelaborator
128
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();
129

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));

ndrumardelaborator
130
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
}
}

131
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:

ndrumardelaborator
132
Completaiaplicaiaprinadugareaunuibutonderesetareacasetelor.

Indrumar de Laborator Java

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Indrumar de Laborator Java

Uploaded by

Copyright:

Available Formats

DominicMirceaKRISTLY AncaVULPE

Se recomand respectarea urmtoarei convenii de notare: numele claselor ncep

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

byte short int long char float double

int ani = tastatura.nextInt();

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

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

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

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

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

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

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

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

Un tablou multidimensional este, de fapt, un tablou de tablouri. n exemplu anterior, tabloul

int notaCopie2[] = new int[4];

// afisarea valorilor in tabel

String s3 = "opt zeci si trei";

String propozitie = "Problema principala este de a gasi grupul de"

A nu se confunda cuvntul cheie void cu 0. Zero este o valoare, pe cnd void

Dac ntro clas este definit un constructor, indiferent de numrul de argumente pe

n exemplul anterior sa declarat o referin i o instan a clasei ntro singur instruciune.

public void print()

// definirea metodei pentru calculul salariului marit cu 5 %

System.out.println("Aria bazei conului este: "

// definirea unui obiect de tip Figura

StudentMasterand a = new StudentMasterand();

A nu se confunda suprancrcarea (overloading) unei metode cu supradefinirea

catch (<tip_exceptie> <id_var_exceptie>)

public String getTipCombustibil()

public static void main(String[] args)

for (int j = 0; j < str2.length; j++)

writeStudentInfo[0] = new Student("Georgescu", "Catalin", "9");

You might also like