UNIVERSITATEA SPIRU HARET
FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ
Modele matematice şi informatice în finanţe, asigurări şi burse de valori
LUCRARE DE DISERTAŢIE
Îndrumător,
Prof. Univ. Dr. Albeanu Grigore
Absolvent,
Dumitru Marius
BUCUREŞTI
2010
1
UNIVERSITATEA SPIRU HARET
FACULTATEA DE MATEMATICĂ ŞI INFORMATICĂ
Modele matematice si informatice în finanţe, asigurări şi burse de valori
ANALIZA SERIILOR DE TIMP
Îndrumător,
Prof. Univ. Dr. Albeanu Grigore
Absolvent,
Dumitru Marius
BUCUREŞTI
2010
2
DECLARAŢIE
Subsemnatul Dumitru Marius , absolvent al Programului de Studii Universitare de Masterat: Modele Matematic şi Informatice în Finanţe, Asigurări şi Burse de Valori denumirea programului Modele Matematic şi Informatice în Finanţe, Asigurări şi Burse de Valori, organizat de Facultatea de Matematică şi Informatică, Universitatea SPIRU HARET, Bucureşti, declar pe propria răspundere că lucrarea de disertaţie cu titlul „ Analiza Seriilor de Timp” este rezultatul muncii mele, pe baza cercetărilor mele şi pe baza informaţiilor obţinute din surse, inclusiv de pe Internet, care au fost citate şi indicate, conform normelor etice, în note şi în bibliografie.
Declar că nu am folosit în mod tacit sau ilegal munca altora şi că nici o parte din lucrare nu încalcă drepturile de proprietate intelectuală ale cuiva, persoană fizică sau juridică.
Declar că lucrarea nu a mai fost prezentată sub această formă vreunei instituţii de învăţământ superior din ţară sau străinătate în vederea obţinerii unui grad sau titlu ştiinţific ori didactic.
Bucureşti,
Dumitru Marius
_________________________ (semnătura în original)
3
Abstract
Software products are very important in now a days especially in fields like assurance, banking or stock exchange. To be updated with information is not enough, it is necessary to have property tools to analyse every piece of data and to predict the next step to succed. My thesis is dedicated to the time series analysis and to represent into a chart any data which we are interested in. The second goal is to create a program which can be updated very easy with new features or models of time series analysis.
My study is structured in three chapters. In the first chapter, I describe mathematical foundations regarding time series and some models of their. In the second chapter I present details regarding implementation part. In the last chapter I present user manual ot this software and a short presentation of the Net Beans program, program where I developed the application.
The most important results obtained during this research and presented in the second chapter is represented by the transformation of the mathematical model into a software solution, easy to use by persons that haven’t studies/ specialized knowledge regarding financial, assurance or stock exchange field
As final remark, my work can be continued by other studens which want to make research in time series field and can develop only some Java classes and update the application.
4
Cuprins
DECLARAŢIE ......................................................................................................... 2
ABSTRACT ............................................................................................................. 3
CUPRINS ................................................................................................................. 4
INTRODUCERE ...................................................................................................... 6
CAPITOLUL 1 – FUNDAMENTE MATEMATICE ................................................ 8
1.1 SERII DE TIMP ................................................................................................... 8 1.2 AUTOCOVARIANŢA ŞI AUTOCORELAŢIA ........................................................... 10 1.3 METODE DE EXTRAGERE A TRENDULUI ............................................................ 11
1. Metoda mediilor parţiale ............................................................................. 11 2. Metoda mediilor mobile ............................................................................... 12
1.4 MODELE DE SERII DE TIMP ............................................................................... 12 1. Modelul aditiv al seriilor de timp ............................................................... 12 2. Modelul multiplicativ al seriilor de timp..................................................... 13 3. Zgomotul alb.............................................................................................. 13 4. Mersul aleator (random walk) .................................................................... 14 5. Procese medie mobilă ................................................................................ 14 6. Procese autoregresive ................................................................................. 18 7. Procese mixate ARMA(p,q) ....................................................................... 19 8. Procese nestaţionare autoregresive şi de medie mobilă ARIMA(p,n,q) ....... 19 9. Modelul ARFIMA (AutoregressiveFractionallyIntegratedMovieAverage) .. 19 10. Seria integrată .......................................................................................... 20 11. Serii cointegrate ....................................................................................... 20 12. Procese ARCH (Autoregressive Conditional Heteroskedasticity) ............. 20
CAPITOLUL 2 - PROIECTARE ŞI IMPLEMENTARE......................................... 28
2.1 PROIECTARE .............................................................................................. 28 2.2 ŞABLOANE DE PROIECTARE ........................................................................ 33
2.2.1 Şablonul Command ............................................................................... 38 2.2.2 Şablonul Model – View - Controller ...................................................... 43 2.2.3 Şablonul Template ................................................................................ 51
2.3 IMPLEMENTARE ......................................................................................... 56 2.4 EXPLICITARE CLASELOR............................................................................. 61
About............................................................................................................... 61
5
ActionMethod .................................................................................................. 61 BrowseFile ...................................................................................................... 62 BrowseUpdate ................................................................................................. 63 Centru .............................................................................................................. 64 Copy_File ........................................................................................................ 65 Data_File ......................................................................................................... 66 ErrMsg ............................................................................................................ 66 Grafic .............................................................................................................. 66 Hdata ............................................................................................................... 68 IOData ............................................................................................................. 68 Logs ................................................................................................................ 72 Main ................................................................................................................ 73 MainWindows ................................................................................................. 73 SetData ............................................................................................................ 74 UpdateApp ...................................................................................................... 75 UserManual ..................................................................................................... 76
CAPITOLUL 3 - UTILIZARE ................................................................................ 78
3.1 MANUAL DE UTILIZARE .............................................................................. 78 3.1.1 Series_Analysis ..................................................................................... 78 3.1.2 Export ................................................................................................... 83 3.1.3 View Logs ............................................................................................. 86 3.1.4 History Data .......................................................................................... 87 3.1.5 Update................................................................................................... 88 3.1.6 Browse .................................................................................................. 89 3.1.7 Load Data ............................................................................................. 90 3.1.8 Grafice .................................................................................................. 92 3.1.9 User Manual .......................................................................................... 92 3.1.10 About ................................................................................................ 93 3.1.11 Eroare ................................................................................................ 94
3.2 NETBEANS IDE 6.8 ................................................................................... 95
CONCLUZII......................................................................................................... 103
BIBLIOGRAFIE................................................................................................... 104
6
INTRODUCERE
De ce am ales acest program de masterat? Motivul a fost acumularea unor cunoştinţe mai vaste asupra domeniilor financiar, bancar şi al asigurărilor. Iubind informatica şi concretizând acest lucru prin proiectele pe care le-am realizat ca free-lancer, dar şi pentru a face faţă solicitărilor impuse de jobul actual (precum şi cele pe care le-am avut) m-au determinat să aleg cursurile acestui program de masterat.
În această lucrare este prezentată o privire de ansamblu asupra modelelor seriilor de timp precum şi un produs software care realizează acest lucru automat.
Deoarece seriile de timp se regăsesc în viaţa cotidiană a fiecăruia dintre noi, uneori chiar fără să ştim, am dezvoltat aplicaţia cât mai general pentru a acoperi o gamă cât mai mare de situaţii.
Deşi iniţial acest proiect a avut un scop pur didactic, fiind conceput pentru a-mi demonstra cunoştinţele dobândite, acum produsul Analiza Seriilor a depăşit această graniţă şi, în prezent, nucleul aplicaţiei este folosit în aplicaţiile dezvoltate de compania în care lucrez pentru analiza diverselor informaţii, printre care şi evoluţia cursului valutar.
Scopul didactic al proiectului nu se rezumă doar la prezentarea şi evaluarea cunoştinţelor propriei persoane, ci şi ale altor masteranzi viitori. La îndemnul domnului profesor Albeanu am concept acest proiect uşor de actualizat/îmbunătăţit cu noi metode de analiză. Astfel viitori masteranzi care doresc sa imi continue proiecul nu au altceva de făcut decât să scrie clasele sursă în Java şi să actualizeze programul prin opţiunile disponibile.
Nucleul proiectului Analiza Seriilor se bazează în proporţie de 50% pe nucleul aplicaţiei Comerţul Electronic ce reprezintă proiectul pentru propria lucrarea de licenţă susţinută în anul 2008 sub îndrumarea Prof. Univ. Dr. Bălănescu Tudor.
În aplicaţia Analiza Seriilor am implementat reprezentarea a două metode de extragere a trendului, modelul Mers Aleator (Random Walk), precum si o reprezentare simplă (un grafic) a unor date într-un format/desen 2D (axele XOY).
7
Cele două metode de extragere a trendului sunt:
- metoda mediilor parţiale – considerând grupele compuse din câte un element/o valoare din mulţimea de valori analizată
- metoda mediilor mobile – considerând un subset de valori compus din fiecare 3 elemente consecutive ale mulţimii analizate.
Toare reprezentările grafice sunt bazate pe clasa Grafic (2.4 Explicitarea claselor - Grafic) având doar unele modificări.
În cazul modelului Mers Aleator, graficul va conţine atât reprezentarea grafică a punctelor/valorilor, cât şi două grafice: cu eroarea aleatoare pozitivă, respectiv negativă.
8
CAPITOLUL 1 – FUNDAMENTE MATEMATICE
În acest capitol sunt prezentate fundamentele matematice care stau la baza acestui proiect. Înainte de a se începe implementarea acestei aplicaţii a trebuit să am la dispoziţie o minimă documentaţie despre ceea ce va trebui sa fac. Aceste lucruri sunt expuse în acest capitol.
1.1 Serii de timp
Zgomotul alb mersul la întâmplare procese medie mobilă (MA(q)) procese autoregresive (AR(p)) procese mixate (ARMA(p,q)) seria integrată (ARIMA(p,n,q), ARFIMA(p,d,q)) serii cointegrate, procese ARCH, GARCH. Seria cronologică reprezintă un set sistematizat de valori ale unei varibile măsurate la momente sau intervale de timp egale şi successive. Seria cronologică este numită şi serie dinamică sau serie de timp. Din punct de vedere matematic, seria de timp este o realizare a unui proces stocastic ttX unde t Z sau unei
mulţimi din Z, iar spaţiul stărilor procesului (adică ,tX ) este mulţimea R sau o submulţime a sa. Exemple de serii cronologice : 1). Cifra de afaceri anuală a unei firme de-a lungul unui deceniu. 2). Numărul şomerilor înregistraţi trimestrial în timpul unei guvernări de 4 ani. 3). Numărul poliţelor încheiate de o societate de asigurări în fiecare trimestru dintr-o perioadă de 5 ani. 4). Încasările zilnice ale unui supermarket pe o perioadă de o lună. 5). Numărul de transporturi efectuate în fiecare trimestru din ultimii 3 ani de către o firmă de transporturi auto internaţionale. Analiza seriei de timp, identificarea, evaluarea şi separarea componentelor oferă informaţii privind :
9
i) trendul, adică existenţa unui sens evolutiv dominant, care se manifestă îndeosebi în condiţii de normalitate ale desfăşurării procesului; ii) apariţia unor oscilaţii periodice sistematice, cu şanse mari de a se repeta şi în viitor, atât ca sens cât şi ca amploare; iii) aspectul previzibil al evoluţiei unor procese, ca răspuns la unele abateri din trecut; iv) identificarea factorilor neesenţiali, permiţând eventuala eliminare a lor; v) caracterul inerţial al desfăşurării unor procese. O primă clasificare a seriilor de timp este dată de împărţirea lor în serii staţionare şi serii nestaţionare.
Seria staţionară este seria ale cărei valori oscilează în jurul unui nivel de referinţă (de echilibru). Vom nota cu tx valoarea de la momentul t şi cu tX variabila aleatoare
de la momentul t a cărei realizare este tx . În limbaj matematic, seria este staţionară
dacă procesul stocastic ttX este staţionar, adică are media şi dispersia constante, iar covarianţa variabilelor din proces depinde numai de distanţa dintre momentele de timp la care sunt înregistrate. Aşadar, avem : 22, tt XDmXM şi tkXXCov ktt ,, . Analize mai amănunţite disting o staţionaritate slabă şi o staţionaritate strictă. Procesul stocastic TttX este complet caracterizat dacă pentru orice întreg 1n şi
orice mulţime de indici distincţi nttt ,...,, 21 este cunoscută funcţia de repartiţie
.,...,,,...,, 2121... 2121 ntttnttt xXxXxXPxxxFnn
Definiţia 1. Procesul stocastic ttX este strict staţionar dacă
0,,...,,..., 1,...,1,..., 11 hxxFxxF nttnhtht nn
şi pentru orice mulţime finită de
indici .,...,, 21 nttt
Definiţia 2. Procesul stocastic ttX este slab staţionar (sau, mai simplu spus,
staţionar) dacă momentele sale de ordin unu şi doi sunt finite, tmXM t , şi
hsshtt XXCovXXCov ,, pentru orice t,s şi h (deci, covarianţa este funcţie numai de distanţa dintre variabile). Pentru staţionaritatea slabă se mai folosesc şi sintagmele : „staţionară de ordinul doi”, „staţionară în covarianţă” sau „staţionară în sens larg”. Observaţie : Dacă TttX este o serie de timp strict staţionară cu 2
tXM (adică
momentele de ordin doi sunt finite), atunci dispersia lui tX este o constantă pentru toţi t. De asemenea, un proces stocastic strict staţionar cu primele două momente finite este şi slab staţionar. În economie majoritatea seriilor cronologice privind preţurile, masa monetară, consumul etc. nu sunt staţionare, sunt nestaţionare,
10
deoarece prezintă tendinţe de creştere sau de scădere în timp (media lui tX depinde de momentul t). În raport cu modalitatea în care se elimină tendinţa din seria de date avem : 1). Serii nestaţionare TSP („trend stationary processes”) sunt serii care prin îndepărtarea tendinţei sunt transformate în serii staţionare. Notând cu tx̂ tendinţa şi
cu ttt xxx ˆ' rezultă că seria ttx ' este staţionară. 2). Serii nestaţionare DSP („difference stationary processes”) sunt serii care se transformă în serii staţionare prin calculul diferenţelor de ordinul întâi
1'
tttt yyyy sau de ordinul doi .12'
tttt xxxx Prin aceste diferenţe se elimină şi trendul. Evident, se pot defini diferenţe şi de alt ordin, inclusiv fracţionar. O modalitate pentru a stabili dacă o serie este de tip TSP sau DSP este dată de testul Dickey-Fuller. Pentru aceasta se pleacă de la un model de forma
ttt xbtaax 110 , unde 10 ,aa şi b sunt parametri iar t este o variabilă
aleatoare de medie zero şi dispersie 02 , .,...,2,1 nt Dacă 01 a şi 1b atunci
seria este de tip DSP. Dacă 01 a şi 1b , atunci seria este de tip TSP. Evident
01 a şi 1b implică tttt axxx 01 care este un proces staţionr oscilând
aleatoriu în jurul lui .0a
1.2 Autocovarianţa şi autocorelaţia
Fiind dată o serie de timp staţionară, ttX , numărul ktt XXCovk , este numit a k
autocovarianţă, iar şirul kk văzut ca o funcţie definită pe Z, este numit funcţia de
autocovarianţă a lui ttX . Pentru 00 definim 0
kk numit a k autocorelaţie
a lui ttX , se mai notează ktt XXCorr , . Evident 10 şi .,1 kk Şirul
kk văzut ca funcţie definită pe Z este numit funcţia de autocorelaţie a lui ttX . Este
mai convenabil de lucrat cu autocorelaţiile deoarece ele sunt invariante la scală. Să considerăm ZttX un proces stocastic staţionar. Pentru funcţia autocorelaţie avem
următoarele proprietăţi. P.1. Funcţia de autocorelaţie este pară în raport cu lag-ul, adică avem ., kkk
Demonstaţie. ttX staţionar implică tktktt XXCovXXCovk ,,
kXXCov ktt , , rezultă
kkkk
00
11
P.2. 1k
Demonstraţie. Avem 2121 ,,0 ktt XXVar . Rezultă
02
,2
2122
222
1
2122
21
kXXCovXVarXVar kttktt
Luând 121 obţinem 022 2 k , 2 k şi
10 2
2
2
kkk
Luând 11 şi 12 obţinem 022 2 k , 2 k , 0
kk
12
2
2
k
. Aşadar 11 k .
1.3 Metode de extragere a trendului 1. Metoda mediilor parţiale constă în următorii paşi : Pasul 1 : Se separă datele seriei în două grupe : una inferioară şi alta superioară. Pasul 2 : Se calculează media aritmetică a fiecărei grupe. Pasul 3 : Se determină mediana momentelor de timp ale fiecărei grupe. Aceasta reprezintă momentul de timp corespunzător mediei aritmetice. Pentru fiecare grupă, se reprezintă grafic punctul de ordonată media aritmetică şi de abscisă momentul de timp corespunzător. Pasul 4 : Dreapta determinată de cele două puncte, reprezentate grafic, constituie trendul cerut.
Exemplul 1. Numărul contractelor de asigurare încheiate de o societate de asigurări în primele 10 luni ale anului 2009 este dat în tabelul : Ianuarie Februarie Martie Aprilie Mai
2000 2400 2600 2500 2300
Iunie Iulie August Septembrie Octombrie
2800 3000 3500 3200 3400
Utilizând metoda mediilor parţiale, să se extragă trendul. Soluţie. Primele 5 luni formează grupa inferioară având media 23601 y cu
12
momentul de timp corespunzător luna martie. Celelalte luni formează grupa superioară având media 31802 y cu momentul luna august.
2. Metoda mediilor mobile constă în calcularea mediei aritmetice a fiecărui subset de q valori consecutive ale seriei date. Mărimea q este denumită perioada mediilor mobile. Formarea unui nou subset presupune scoaterea primei valori din subsetul anterior, păstrarea celorlalte q-1 valori şi introducerea în subset a următoarei valori din şirul valorilor seriei date. Mediile mobile calculate reprezintă chiar componentele (valorile) trendului seriei cronologice date. La stabilirea perioadei mediilor mobile trebuie avută în vedere necesitatea ca aceasta să coincidă cu lungimea ciclului natural al seriei. De exemplu, la determinarea trendului numărului de şomeri înregistraţi trimestrial de-a lungul mai multor ani, perioada mediilor mobile va fi 4; la determinarea trendului încasărilor zilnice ale unui supermarket, înregistrate pe mai multe luni, perioada mediilor mobile va fi 7.
În cazul exemplului de la punctul 1, mediile mobile de perioadă 5 sunt :
tx 2000 2400 2600 2500 2300 2800 3000 3500 3200 3400
Totaluri
mobile
11800 12600 13200 14100 14800 15900
Medii
mobile
2360 2520 2640 2820 2960 3180
În cazul în care mediile mobile sunt folosite pentru reprezentarea grafică a trendului şi se vrea reprezentarea valorilor acestuia în anumite momente de timp, există o metodă de centrare a mediilor mobile, metodă care necesită calculul mediilor aritmetice pentru perechile succesive de medii mobile.
1.4 Modele de serii de timp 1. Modelul aditiv al seriilor de timp RSTY unde : Y este valoarea cunoscută a seriei de timp, T este componenta trend, S este componenta sezonieră,
R este componenta reziduală.
13
2. Modelul multiplicativ al seriilor de timp RSTY unde : Y, T, S, R au semnificaţia mai sus.
3. Zgomotul alb O serie de timp ttX formată din variabile aleatoare necorelate, cu media zero şi
dispersia 02 , se numeşte zgomot alb. Evident, ea este staţionară, având funcţia
de autocovarianţă
rest in ,0
0,2 kk
,
şi funcţia de autocorelaţie
restin ,00,1 k
k
Se notează 2,0 WN (White Noise), deci 2,0~ WNX t . Zgomotul alb mai este
denumit şi proces pur aleator. Dacă elementele lui tX sunt i.i.d. (independente şi identic repartizate), atunci seria de timp este strict staţionară (se mai scrie 2,0~ IIDX t ). Când tX -urile au repartiţia normală, spunem că zgomotul alb este gaussian. În cazul unui zgomot alb gaussian cele două definiţii privind staţionaritatea coincid, deci seria este atât staţionară cât şi strict staţionară. Un proces tX este un zgomot alb cu media m dacă 2,0~ WNmX t . Cu zgomotul alb se pot construi multe modele de serii de timp. Exemplu : Seria de timp tZ unde 1 ttt UUZ , 0 şi 2,0~ WNU t
este numită medie mobilă de ordinul întâi (ordin unu). Se notează 1~ MAZ t . Această serie de timp este staţionară pentru orice , are media 0, funcţia de
autocovarianţă
restin ,0
1,0,1
2
22
kk
k
şi funcţia autocorelaţie
restin ,0
1,1
0,1
2 k
k
k
Evident 211 . Procesul MA(1) este cel mai simplu exemplu de filtru liniar.
14
4. Mersul aleator (random walk) Se consideră tX un proces discret pur aleator (adică t Z şi variabilele aleatoare
tX sunt independente şi identic repartizate) cu media m şi dispersia 2X . Procesul
tZ unde ttt XZZ 1 se numeşte mers aleator. În mod obişnuit procesul este
pornit de la zero când 0t , astfel că 11 XZ şi
t
iit XZ
1. Avem :
mtmXEZEt
i
t
iit
11 şi 2
1
2
1X
t
iX
t
iit tXVarZVar
Observaţie : Cum media şi dispersia depind de t, mersul aleator este nestaţionar. Totuşi, este interesant că diferenţele de ordinul întâi ale mersului aleator dau un proces pur aleator care este staţionar, deci tX unde 1 ttt ZZX este staţionar. Cele mai cunoscute exemple de serii de timp care se comportă foarte mult ca mersul aleator (la întâmplare) sunt preţurile acţiunilor (share prices). În acest caz un model care corespunde datelor este : Preţul acţiunii în ziua t = preţul acţiunii în ziua (t-1) + o eroare aleatoare.
5. Procese medie mobilă Se consideră tZ un zgomot alb (sau, mai restrictiv, un proces pur aleator, pentru că
în locul necorelării se consideră independenţa) cu media zero şi dispersia 2Z .
Procesul tX , unde 1.5110 qtqttt ZZZX ,
iq ,0,00 -urile sunt constante, se numeşte proces medie mobilă de ordin q
(abreviat MA(q)).În mod uzual Z-urile sunt scalate, astfel că 10 . Plasându-ne în
ipoteza mai restrictivă ( tZ -urile independente), obţinem : 0tXE şi
q
iiZtXVar
0
22 . Avem : ktt XXCovk ,
qktqktktqtqtt ZZZZZZCov 110110 ,
qk
qk
qk
qk
kq
ikiiZ
kq
ikiiZ
,0
,,2,1,
,,1,0,
,0
0
2
0
2
Cum k nu depinde de t şi media este constantă, rezultă că procesul tX este slab
staţionar (altfel zis, staţionar de ordinul doi) pentru toate valorile lui i . Mai mult,
15
când tZ -urile sunt repartizate normal, atunci şi tX -urile sunt repartizate normal. Deci, procesul este complet determinat de medie şi funcţia autocovarianţă. Funcţia de autocorelaţie a procesului MA(q) este
qk
qkqkk
k
q
ii
kq
ikii
,,2,1
sau ,00,1
0
2
0
În particular, procesul MA(1) cu 10 are funcţia autocorelaţie
restin 0
1,1
0pentru 1
21
1 k
k
k
Să menţionăm că funcţia autocorelaţie taie (întrerupe) la lag-ul q, ceea ce constituie o trăsătură a proceselor MA. Privitor la condiţiile ca un MA proces să fie staţionar vom face următoarele consideraţii. Fie următoarele procese MA de ordinul întâi : 1). 1 ttt ZZX
2). 11
tt ZX
Primul proces are funcţia autocorelaţie
restin ,0
1,1
0,1
21 k
k
k
Al doilea proces are funcţia autocorelaţie
restin 0
1,111
10,1
222 k
k
k
Aşadar, avem 21 . Astfel se vede că un MA proces nu poate fi identificat după funcţia autocorelaţie.
16
Punând în cele două modele tZ în termeni de ,, 1tt XX , prin substituiri succesive obţinem :
A). 211 tttttt ZXXZXZ
33
22
1 tttt XXXX B).
221211
11111ttttttttt XXXZXXZXZ
Dacă 1 , atunci seria de la A este convergentă iar seria de la B este divergentă.
Astfel, o procedură de estimare care implică estimarea reziduurilor, duce în mod natural la modelul A, care se zice că este invertibil (în acest caz modelul B nu este invertibil). Condiţia de invertibilitate ne asigură unicitatea procesului MA pentru o funcţie autocorelaţie dată. Această condiţie pentru un proces MA de ordin general este exprimată cel mai bine folosind operatorul de schimbare (mutare, dare) înapoi, notat cu B, care este definit prin jXXB jtt
j . Astfel, ecuaţia (5.1) se va scrie
ttq
qt ZBZBBBX 2210 , unde B este un polinom
de ordin q în B. Un MA proces de ordin q este invertibil dacă toate rădăcinile ecuaţiei 2.502
210 qq BBBB se află în afara cercului unitate.
De notat că în ecuaţia (5.2) B este văzut ca o variabilă complexă şi nu ca un operator. De asemenea, se poate adăuga în (5.1) o constantă arbitrară m în membrul drept, ceea ce dă un proces de medie m. Cum aceasta nu schimbă funcţia autocorelaţie pentru simplificare va fi omisă. Privitor la formalizarea matematică, se numeşte proces medie mobilă finită procesul
stocastic tX t ; Z}, unde
MZXM
Mjjtjt , N, j R, 0,0 MM şi
tZ -urile sunt variabile aleatoare necorelate 2,0 , adică 0tZE şi 2tZVar
(mai restrictiv, sunt considerate independente). Procesul medie mobilă infinită tX
este dat de reprezentarea
jjtjt ZX , unde nu există un număr natural M astfel
încât jj ,0 Z cu .Mj Procesul definit de ,0
q
jjtjt ZX unde
00 şi 0q se numeşte proces medie mobilă cu o latură de ordin q (mai precis
este un proces medie mobilă stânga de ordin q, pe scurt proces medie mobilă de ordin q). Aceasta pentru că punând qtt Z şi qii avem
q
iiti
q
iqitqiqji
q
qjjtjt ZZX
2
0
2
0 , deci nu se pierde din generalitate
17
dacă se consideră numai reprezentarea cu o latură. Un proces medie mobilă de ordin infinit cu media nenulă , dat de
0iitit ZX este numit proces liniar general (aceasta pentru că procesele de
acest tip se obţin trecând un proces pur aleator printr-un sistem liniar. Câteva cuvinte despre sistemele liniare. Să considerăm că sunt date observaţii (înregistrări) asupra intrărilor (inputurilor) şi ieşirilor (outputurilor) unui sistem, notate în cazul în care timpul este discret cu tt yx , şi cu tytx , în cazul timpului continuu. Definiţie. Fie tyty 21 , ieşirile corespunzătoare intrărilor ., 21 txtx Sistemul se numeşte sistem liniar dacă şi numai dacă orice combinaţie liniară de intrări (să zicem
txtx 2211 ) produce aceeaşi combinaţie liniară de ieşiri, adică tyty 2211 , 21 , fiind constante.
Definiţie. Dacă intrarea tx produce ieşirea ty , atunci sistemul se zice că este invariant în timp dacă o întârziere de timp la intrare produce aceeaşi întârziere la ieşire, adică tx produce ieşirea ty , altfel zis relaţia intrare-ieşire nu se schimbă cu timpul.
a) Sisteme liniare în timp
Un sistem liniar invariant în timp se poate scrie sub forma
kktkt xhy pentru
cazul timpului discret, sau sub forma
duutxuhty pentru cazul timpului
continuu. Funcţia de ponderare uh (pentru timpul continuu) sau kh (pentru timpul discret) arată o caracterizare (descriere) a sistemului în timp şi este cunoscută sub numele de FIR (Funcţia Impuls Răspuns). Un exemplu foarte simplu de sistem liniar este dat de „întârzierea simplă”, adică dtt xy unde întregul d arată timpul de
întârziere. Funcţia sa FIR este :
restin 0
pentru 1 dkhk
Alt exemplu de sistem liniar este „câştigul pur”, adică tt xcy unde constanta c
reprezintă câştigul. FIR –ul acestui sistem este :
restin 0
0pentru kchk
b). Sisteme liniare în frecvenţă O altă cale de descriere a unui sistem liniar este prin intermediul unei funcţii
18
denumită funcţia de transfer (FRF – Funcţia Răspuns Frecvenţă). Aceasta este
transformata Fourier a funcţiei FIR, adică este 0,
dueuhH ui în
cazul timpului continuu şi este k
kik ehH , 0 .
Întrun sistem liniar o intrare exponenţială complexă titetx ti sincos dă o ieşire txHty . Pentru sistemul liniar „întârzierea simplă”, txty unde este o constantă, funcţia FIR este uuh unde este funcţia delta
Dirac, adică
00,0
tt
t , astfel încât 1
dtt (altfel zis, pentru orice
funcţie t care este continuă în 0t , funcţia delta Dirac este funcţia care
verifică 0
dttt . Funcţia de transfer este dată de
iui edueuH .
6. Procese autoregresive
Dacă tZ este un proces pur aleator cu media 0 şi dispersia 2Z , atunci un proces
tX se zice că este proces autoregresiv de ordin p dacă
)1.6(2211 tptpttt ZXXXX
Acest model seamănă cu modelul regresiei multiple, dar diferenţa constă în faptul că
tX nu este regresat peste variabile independente ci peste valorile din trecut. Se utilizează abrevierea AR(p) proces. Procese de ordinul întâi : 1p şi )2.6(1 ttt ZXX Prin substituţii succesive obţinem :
22
1121 ttttttttt ZZZZZXZXX
pentru 11 . Deci tX poate fi exprimat ca un proces medie mobilă de ordin infinit. Utilizând operatorul de mutare înapoi (întoarcere) B, ecuaţia (6.2) se scrie tt ZXB 1 , astfel că
ttt ZBBZBX 221 11
22
1 ttt ZZZ
Rezultă : 0tXE şi 422 1 ZtXVar
Astfel, dispersia este finită dacă 1 , caz în care avem : 22
2
1 XZ
tXVar
19
Funcţia autocovarianţă este :
jjkt
j
iit
iktt ZZEXXEk
0
2
i
ikiZ pt. 0k
Aceasta converge în cazul 1 la 22
2
1 XkZkk
Pentru 0k găsim kk .
Deoarece k nu depinde de t, un proces AR(1) este slab staţionar dacă 1 .
Funcţia autocorelaţie este : ,2,1,0,0 2
2
kkk k
X
Xk
Pentru toţi întregii k avem ,2,1,0, kk k Mai simplu, funcţia autocorelaţie poate fi găsită presupunând apriori că procesul este staţionar, în care caz 0tXE . Înmulţind ecuaţia (6.2) cu ktX şi luând media
obţinem : pentru 1:0 kkk presupunând că 0 ktt ZZE Deoarece k este o funcţie pară, trebuie să avem 1 kk pentru .0k
7. Procese mixate ARMA(p,q)
Sunt procese tX autoregresive de ordin p cu reziduuri medie mobilă de ordin q care
verifică relaţia qtqttptptt ZZZXXX 1111 , unde
tZ -urile sunt reziduuri medie mobilă de ordin q.
8. Procese nestaţionare autoregresive şi de medie mobilă ARIMA(p,n,q) Sunt procese nestaţionare care în forma originală prezintă tendinţă şi prin diferenţe de ordin n pot fi aduse la forma staţionară, p fiind ordinul părţii autoregresive şi q ordinul părţii medie mobilă a modelului. Pentru ARIMA(1,1,2) ecuaţia este :
2211110 ttttt ZZZyyy
9. Modelul ARFIMA (AutoregressiveFractionallyIntegratedMovieAverage) Este o variantă a modelului ARIMA(p,d,q) în care d este ordinul diferenţei şi este o fracţiune din 1 (0<d<1). Folosind operatorul de diferenţiere înapoi (trimitere în trecut) B avem : 10,,0~,1 2 dNzzyB zttt
d , unde
32
!321
!2111 BdddBddBdB d
Astfel, forma generală a lui ARFIMA este ttd zByBB 1 , unde B,, au
semnificaţiile : tt zyB (modelul AR(p), adică
20
tptptt zyyy 110 )
tt zBy (modelul MA(q), adică qtqttt zzzyy 11 )
10. Seria integrată Seria integrată este seria de timp nestaţionară care prin diferenţele de ordinul întâi sau doi (adică 1
21 , tttttt yyyyyy ) poate fi transformată în serie
staţionară.
11. Serii cointegrate Sunt seriile cronologice care fiind integrate de acelaşi ordin admit o combinaţie liniară care este staţionară (integrată de ordin zero) sau este integrată de ordin mai mic decât ordinul de integrare a seriilor iniţiale. Exemplu. Seriile tt yx , au acelaşi ordin de integrare şi există tz , unde
ttt xbayz care este staţionară.
12. Procese ARCH (Autoregressive Conditional Heteroskedasticity) Prind împrăştierile inegale (eteroschedasticitate) ale valorilor reziduale în timp (adică o dependenţă sub forma autocorelaţiei şi pentru variabilele reziduale). F.R. Engle a propus ca dispersia erorii să fie dependentă de valorile 1ty sau .1tz Astfel
avem : 2110
2 ttz y sau varianta 22
1102
ptpttz zz .
Spre deosebire de modelul AR în care eroarea tz este considerată aleatoare,
repartizată normal şi cu dispersia constantă, iar 11 ttt yayyE (media
condiţionată este dependentă de timp), în versiunea lui Engle dispersia erorii este dependentă de timp (de aici iniţialele CH adăugate lui AR). O variantă simplă a modelului este : tttt zxbyay 1 , unde 2
11022 ,,0~ ttztzt zNz
O limitare importantă a modelelor ARMA este dată de faptul că tratează prea rigid varianţa condiţionată a lui ktX . Clasa proceselor ARMA cu heteroscedasticitate condiţional autoregresivă sau ARMA-ARCH procese permite varianţei condiţionate a lui tX să depindă de istoria procesului. O serie de timp cu media zero, tX , este un
proces pur ARCH(1) dacă 1,0~, IIDYYX tttt , (se scrie tX ~ARCH(1)),
unde t (volatilitatea stocastică) este un element al procesului stocastic care verifică
relaţia 21
22 tt X , cu 0 şi 0 . Deoarece
21
221
2 tttt XSXE , un proces ARCH(1) pentru tX corespunde unui
proces AR(1) pentru .2tX Dacă 10 , atunci procesul ARCH(1) este staţionar şi
21
varianţa sa necondiţionată este
1
22. Diferenţa dintre varianţa condiţionată şi
necondiţionată este 221
22 tt X . Avem
221
222
12
1 ttttt SXESXE
Repetând această formula obţinem ,2,1,22
112
12
kXSXE t
ktkt
Astfel, 2
12 ktkt SXE .
O generalizare simplă a procesului pur 1ARCH este procesul pur mARCH , unde 22
1122
mtmtt XX cu ,1,1,0 mjj şi ,0m care
corespunde unui proces mAR pentru .2tX
Definiţie. O serie de timp tX este numită proces mARCHqpARMA , dacă
satisface relaţia ,tt YBΘXBΦ mARCHYt ~ unde B şi B sunt polinoame în lag- operatorul de ordin p şi, respectiv q. Mai general este un proces având heteroscedasticitate generalizată condiţional autoregresivă (GARCH) de ordin mr, , generalizarea lui Bollerslev, unde
2211
2211
22mtmtrtrtt XX , cu
1,1,0,1,1,0,0, mjri jimr . Avem mGARCHmARCH ,0 .
Notând 22ttt XV , atunci un proces GARCH mr, poate fi scris
rtrtptptt VVXXX 1122
112 unde
0,,,max jjjjrmp for mj şi 0j pentru .rj Deci un
proces mrGARCH , pentru tX corespunde unui proces rpARMA , pentru .2tX
Definiţie. O serie de timp tX este numită proces mrGARCHqpARMA ,, dacă
satisface relaţia ,tt YBΘXBΦ mrGARCHYt ,~ .
Pentru exemplificarea noţiunilor legate de modelele autoregresive, am făcut inferenţă statistică pentru determinarea coeficienţilor prin metoda celor mai mici pătrate pe datele din rapoartele anuale ale Comisiei de Supraveghere a Asigurărilor şi apoi am efectuat predicţiile 211
~,ˆ ttttt XXXXX ,
valorilor de interes în două cazuri : întâi predicţia pas cu pas (adică datele din anul anterior sau din anii anteriori sunt cele raportate de CSA), apoi predicţia pe termen lung (caz în care, în predicţie, se folosesc predicţiile anterioare şi nu datele raportate, deci ar fi cazul elaborării unor prognoze pe termen lung).
22
Tabel. 1. Valoarea totală a primelor de asigurare brute încasate din asigurări directe:
An Prime totale încasate (lei noi)
Prime încasate în asigurările de viaţă
Prime încasate asig. generale
1997 130402200 8073900 122328300
1998 241484000 19944700 221539300
1999 427393000 50569000 376824000
2000 673887300 106658600 567228700
2001 1001242500 211473300 789769200
2002 1645965600 414514000 1231451600
2003 2422508810.2 579003012 1843505798.2
2004 3216393971.5 693443836.2 2522950135.3
Sursa : Rapoartele Anuale ale CSA
Tabelul 2. Predicţii pentru primele brute încasate din asigurările directe
Anul
Prime brute încasate* (Xt)
Predicţii pas cu pas tX̂ Predicţii pe termen
lung tX̂̂
1997 130,402,200 --- ---
1998 241,484,000 311,729,066.9 311,729,066.9
1999 427,393,000 458,654,611.1 551,566,273.3
2000 673,887,300 704,552,507.8 868,793,866.4
2001 1,001,242,500 1,030,585,298 1,288,384,085
2002 1,645,965,600 1,463,571,087 1,843,367,180
2003 2,422,508,810.2 2,316,332,676 2,577,431,565
2004 3,216,393,971.5 3,343,449,933 3,548,362,980
2005 4,384,987,227** 4,393,505,021 4,832,593,399
* Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise.
23
Eroarea relativă pentru predicţiile din 2005 este de 0.2% în cazul pas cu pas şi de 2.7% pe termen lung. Pentru predicţia îndemnizaţiilor brute plătite de asigurători pentru asigurările directe generale şi de viaţă, atât cumulate cât şi separate, am folosit două modele lineare.
Tabelul 2’. Situaţia pe date deflatate
Anul
Prime brute încasate deflatate (Xt)
Predicţii
tX̂
Predicţii
tX~
1997 130,402,200 --- ---
1998 171,752,489.3 157,729,471.75 ---
1999 196,368,185.8 210,083,500.22 203,946,382.41
2000 220,057,866.1 241,249,687.82 236,706,333.31
2001 250,925,319.5 271,243,436.77 267,667,960.66
2002 350,171,401 310,325,038.33 307,698,100.38
2003 451,689,130.8 435,981,527.41 434,715,398.98
2004 548,685,334.6 564,514,173.86 567,163,062.07
2005 688,799,178.4 687,322,069.45 693,961,104.10
Eroarea relativă pentru predicţia din 2005 este de 0,2% la modelul de ordinul întâi şi de 0,75% la modelul de ordin doi, iar eroarea relativă totală a predicţiilor este de 2% la ambele modele. Predicţia pentru 2006 este de 875,273,474.23 pentru date deflatate (5,990,015,464 lei).
Tabelul 3. Predicţii pentru îndemnizaţiile (despăgubirile) brute plătite
Anul Îndemnizaţii *
(Xt)
Predicţii pas cu pas
tX̂
Predicţii pas cu pas
tX~
1997 69,925,100 --- ---
1998 102,212,700 114,022,130.901 ----
24
1999 189,589,900 161,229,924.099 193,403,696.19
2000 248,978,900 288,984,380.539 273,600,712.37
2001 406,293,900 375,817,208.937 420,965,932.04
2002 649,832,600 605,827,924.718 567,138,913.81
2003 842,267,901 961,906,561.258 886,204,782.46
2004 1,311,879,000 1,243,266,770.548 1,307,528,164.13
2005 1,758,745,510 1.929,886,514.498 1,765,377,520.80
* Sursa : Rapoartele Anuale ale CSA.
Eroarea relativă a predicţie tX̂ pentru anul 2005 este de 9.7%. Definind eroarea
relativă totală (ERT) a predicţiilor tX̂ ca
tt
ttt
X
XXERT
2ˆ
, rezultă că ERT
este egală cu 4.2%. Eroarea relativă a predicţiei tX~ pentru anul 2005 este egală cu 1.8%. Folosind modelul autoregresiv linear de ordinul întâi pentru primele brute încasate în contractele directe de asigurări generale (non-life) am obţinut
131273.155.103034505 tt XX cu care am făcut predicţiile din tabelul 4.
Tabelul 4. Predicţii pentru primele brute încasate din asigurările generale directe
Anul Prime brute
încasate* (Xt)
Predicţii pas cu pas
tX̂
Predicţii pe date
deflatate
1997 122,328,300 --- ----
1998 221,539,300 263,618,589.2 141,284,469.84
1999 376,824,000 393,855,889.4 186,451,070.54
2000 567,228,700 597,702,842.7 206,403,634.37
2001 789,769,200 847,652,889.3 221,905,572.13
25
2002 1,231,451,600 1,139,788,578.9 238,181,828.83
2003 1,843,505,798.2 1,719,598,512.4 320,287,350.82
2004 2,522,950,135.3 2,523,060,692.3 425,063,112.95
2005 3,346,997,220** 3,414,987,959.3 536,137,273.30***
*Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise, ***3,413,121,224.82 lei.
Eroarea relativă pentru predicţia din anul 2005 este de 2,03%, iar eroarea relativă totală a predicţiilor este de 1,709%. Predicţia pentru volumul primelor brute încasate din asigurările generale directe în 2006 este de 4,496,739,655.42 lei. În cazul datelor deflatate, eroarea relativă a predicţiei pentru 2005 este de 1,975%, iar eroarea relativă totală a predicţiilor este de 2,291%. În cazul asigurărilor de viaţă modelul obţinut este
1193007.134.59577744 tt XX , iar pentru date deflatate este
107045.113244.12430011ˆ tt XX .
Tabelul 5. Predicţii pentru primele brute încasate din asigurările de viaţă directe
Anul Prime brute
încasate* (Xt)
Predicţii pas cu pas
tX̂
Predicţii pe date
deflatate
1997 8,073,900 --- ----
1998 19,944,700 69,209,965.58 21,072,716.00
1999 50,569,000 83,371,916.04 27,614,791.13
2000 106,658,600 119,906,927.96 37,301,077.42
2001 211,473,300 186,822,227.40 49,713,089.73
2002 414,514,000 311,866,924.39 69,161,879.41
2003 579,003,012 554,095,951.49 106,828,585.53
2004 693,443,836.2 750,332,535.32 127,993,713.31
2005 1,037,990,007** 886,861,268.27 139,058,586.40***
* Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise, ***885,265,455.84 lei.
26
Eroarea relativă totală a predicţiilor este de 6,54%, eroarea predicţiei pentru 2005 este de 14,5% (mare, deci modelul linear de ordinul 1 nu e recomandabil pentru prognoze aici), iar predicţia pentru 2006 este de 1,297,907,347.92 lei. În cazul datelor deflatate eroarea relativă a predicţiei pe 2005 este de 14,7%, iar eroarea relativă totală a predicţiilor este de 5,54%.
Folosind modelul autoregresiv linear de ordinul doi pentru primele brute încasate în contractele directe de asigurări generale (non-life) am obţinut
21 346886.0124101.132.88208606 ttt XXX cu care am făcut predicţiile din tabelul 6.
Tabelul 6. Predicţii pentru primele brute încasate din asigurările generale directe
Anul Prime brute încasate* (Xt)
Predicţii tX~
1997 122,328,300 ---
1998 221,539,300 ---
1999 376,824,000 379,675,001.99
2000 567,228,700 588,645,501.15
2001 789,769,200 856,545,575.45
2002 1,231,451,600 1,172,752,146.19
2003 1,843,505,798.2 1,746,443,710.78
2004 2,522,950,135.3 2,587,667,497.91
2005 3,346,997,220** 3,563,744,112.26
Sursa : Rapoartele Anuale ale CSA, **Prime brute subscrise.
Eroarea relativă pentru predicţia din anul 2005 este de 6,4%, iar eroarea relativă totală a predicţiilor este de 2,45%. Predicţia pentru volumul primelor brute încasate în asigurările generale directe este de 4,725,745,436.68 RON. Folosind modelul autoregresiv linear de ordinul doi pentru îndemnizaţiile brute şi valorile de răscumpărare plătite în contractele directe de asigurări de viaţă am obţinut
21 010592.0371383.0816.144,593,41 ttt XXX cu care am făcut predicţiile din tabelul 7.
27
Tabelul 7. Predicţii pentru îndemnizaţiile brute şi răscumpărările plătite în asigurările de viaţă directe
Anul
Îndemnizaţii brute
Plătite* (Xt)
Predicţii
tX~
1997 1,858,700 ---
1998 4,082,800 ---
1999 12,053,200 43,129,113.47
2000 8,343,700 46,112,740.37
2001 57,633,200 44,819,515.05
2002 142,947,200 63,085,501.75
2003 62,499,098 95,291,716.14
2004 75,280,471 66,318,282.14
2005 97,385,521 70,212,989.45
*Sursa : Rapoartele Anuale ale CSA
Eroarea relativă pentru predicţia din anul 2005 este de 27,9% (mare !), iar eroarea relativă totală a predicţiilor este de 22,81%. Predicţia pentru volumul îndemnizaţiilor brute plătite în asigurările de viaţă directe este de 78,557,801.97 RON. Evident, erorile mari arată neadecvarea modelului pentru prognoze. Această evoluţie prea sinuoasă a acestor sume se explică în parte şi prin influenţa schimbărilor din legislaţie, care au reîncadrat anumite produse la altă categorie de asigurări, şi prin faptul că evoluţia asigurărilor de viaţă a înregistrat explozii şi prăbuşiri.
28
CAPITOLUL 2 - PROIECTARE ŞI IMPLEMENTARE
În acest capitol este prezentată transpunerea formulelor matematice într-un mod mai plăcut utilizatorului, persoanei care doreşte să analizeze datele prin metodele implementate.
Astfel, în capitolul 2 sunt prezentate ideile, şabloanele, modalităţile care au condus la transformarea unor date abstracte - numerele, în lucruri vizibile, palpabile – grafice, imagini care pot fi imprimate.
2.1 Proiectare
Înainte de implementarea claselor se analizează cerinţele aplicaţiei şi se fac grafice pentru evidenţierea cazurilor de utilizare şi observarea relaţiilor dintre clase – pentru a uşura activitatea de implementare.
Figură 2.1-1
29
Astfel, în acest proiect se doreşte existenţa doar a unei singure categorii de utilizatori. Acest poate fi atât client cât şi administrator. Utilizatorul va avea posibilitatea de a vizualiza datele sub forma unui grafic, îl va putea printa şi va putea alege oricând un nou set de date. De asemenea utilizatorul va putea adăuga noi funcţii sau moduri de afişare a graficelor din program prin opţiunea de actualizare.
Etapele pe care le urmează un utilizator pentru vizualiza datele sub forma unui grafic sunt oferite de diagramele de mai jos (Figură 2.1-2 şi Figură 2.1-3).
Figură 2.1-2
30
Un utilizator rulează programul şi accesează meniul File, submeniulUpdate (Figură 3.1.1-2). În această stare el poate să aleagă fişierele pe care doreşte să le importe în aplicaţie. În momentul în care doreşte să importe o nouă metodă de analiză şi afişare a datelor va trebui să bifeze checkbox-ul de lângă butonul Update.(Figură 3.1.5-2).
Notă: Ultima dată se importă fişierele care conţin metodele apelate din interfaţă ce vor analiza şi afişa datele.
Apăsarea butonului Browse va deschide o fereastră care permite selectarea fişierului ce va fi importat (Figură 3.1.6-1).
După selectarea fişierului şi apăsarea butonului Load File se va reafişa fereastra Upload. Această iteraţie se va repeat pentru fiecare fişier care trebuie importat.
Fişierele vor fi importate în momentul ieşirii din program. Pentru a se folosi noua (noile) metodă(e) va trebui repornită aplicaţia deoarece în procesul de update executabilul aplicaţiei, fişierul .jar se va suprascrie, iar Java – şi în general orice fişier care rulează la un momentdat, nu se poate suprascrie în timpul execuţiei. El trebuie obligatoriu să fie închis/oprit pentru această operaţie.
Figură 2.1-3
31
Întreg acest flux este descris în graficele de mai jos.
Pentru cazul de utilizare din Figură 2.1-4 diagrama stărilor este prezentată mai jos (Figură 2.1-5 şi Figură 2.1.6). Actualizarea programului necesită restartarea acestuia deoarece copierea şi compilarea claselor se fac cu procese Windows care sunt externe proceselor Java.
În urma procesului de actualizare fişierul .jar, care reprezintă executabilul acestui program, se suprascrie, de aici şi nevoia de executare a proceselor de copiere externe Java şi executarea lor atunci când programul nu rulează.
Figură 2.1-4
32
Întreg fluxul de update al aplicaţiei poate fi redat prin diagrama de mai jos- Figură 2.1-6.
Figură 2.1-5
Figură 2.1-6
33
2.2 Şabloane de proiectare Definiţie
Toate sistemele orientate pe obiecte (OO) bine structurate abundă în şabloane (patterns), mergând de la mecanisme care conturează forma sistemului în ansamblu, până la şabloane locale (cum ar fi de exemplu modul de tratare a excepţiilor).
Un şablon reprezintă o soluţie comună a unei probleme într-un anumit context.
Importanţa şabloanelor (standardelor) în construirea sistemelor complexe a fost de mult recunoscută în alte discipline. În cadrul comunităţii proiectanţilor de software OO ideea de a aplica şabloane se pare că a fost inspirată de propunerea unui arhitect, Christopher Alexander, care a lansat iniţiativa folosirii unui limbaj bazat pe şabloane pentru proiectarea clădirilor şi a oraşelor. Acesta afirma că: "Fiecare şablon descrie o problemă care apare mereu în domeniul nostru de activitate şi indică esenţa soluţiei acelei probleme, întrun mod care permite utilizarea soluţiei de nenumărate ori în contexte diferite". Deşi în domeniul sistemelor OO soluţiile sunt exprimate în termeni de obiecte şi interfeţe (în loc de ziduri, uşi, grinzi etc), esenţa noţiunii de şablon este aceeaşi, adică de soluţie a unei probleme întrun context dat. [6]
Clasificare
Şabloanele utilizate în sistemele OO pot fi clasificate într-o ierarhie, după cum urmează:
idiomuri
mecanisme
cadre (frameworks).
Un idiom este legat de un anumit limbaj de programare şi reprezintă o convenţie general acceptată de utilizare a limbajului respectiv. Importanţa acestui idiom constă în faptul că el reprezintă un anumit stil acceptat de comunitatea "vorbitorilor" de C şi orice programator care citeşte o secvenţă C recunoaşte imediat această convenţie. Violarea acestui idiom are drept consecinţă producerea de cod greu de înţeles, chiar dacă este corect.
Practic, fiecare limbaj de programare îşi are propriile sale idiomuri. Se poate spune că un idiom este o formă de reutilizare pe scară mică. [6]
Un mecanism este o structură în cadrul căreia obiectele colaborează în vederea obţinerii unui anumit comportament care satisface o anumită cerinţă a
34
problemei. Mecanismele reprezintă decizii de proiectare privind modul în care cooperează colecţiile de obiecte. Ele se mai numesc şabloane de proiectare (design patterns). Majoritatea sistemelor OO includ mecanisme referitoare la:
persistenţa obiectelor
controlul stocării
controlul proceselor
transmisia/recepţia mesajelor
distribuirea şi migrarea obiectelor
conectarea în reţele (networking)
tranzacţii
evenimente
modul de prezentare ("look & feel") al aplicaţiei.
Un cadru reprezintă o colecţie de clase care oferă un set de servicii pentru un domeniu particular. Cadrul exportă un număr de clase şi mecanisme pe care utilizatorii le pot adapta. Cadrele sunt forme de reutilizare pe scară largă. Cele mai răspândite tipuri de cadre sunt cele destinate creării de interfeţe grafice.
Proiectarea sistemelor OO este o activitate dificilă, iar proiectarea sistemelor OO reutilizabile este încă şi mai grea. Soluţia trebuie să fie specifică problemei, dar totodată suficient de generală.
Un proiectant fără experienţă este de multe ori copleşit de multitudinea opţiunilor disponibile şi are tendinţa de a se întoarce la tehnicile non-obiectuale pe care le-a folosit în trecut. Un proiectant experimentat ştie că nu trebuie să rezolve fiecare problemă începând de la zero, ci reutilizând soluţii din proiecte anterioare. Atunci când descoperă o soluţie bună o va folosi mereu. Acest tip de experienţă este o parte din ceea ce conferă unui proiectant statutul de expert.
Elementele de bază ale unui şablon de proiectare:
numele şablonului: descrie sintetic problema rezolvată de şablon şi soluţia;
problema: o descriere mai largă a problemei rezolvate şi a contextului în care ea apare;
35
soluţia: o descriere a elementelor de proiectare utilizate şi a relaţiilor dintre ele. Soluţia nu descrie un proiect particular sau o implementare concretă, ci un ansamblu abstract de clase şi obiecte care rezolvă un anumit gen de probleme de proiectare;
consecinţele şi compromisurile implicate de folosirea şablonului: acestea pot privi impactul asupra flexibilităţii, extensibilităţii sau portabilităţii sistemului, după cum pot să se refere la aspecte ale implementării sau limbajului de programare utilizat. Compromisurile sunt de cele mai multe ori legate de spaţiu şi timp.
Deoarece există multe şabloane de proiectare, este necesară o anumită clasificare a lor, în vederea alcătuirii unui catalog cu ele.
Criterii de clasificare:
- scop: şabloanele pot fi, din acest punct de vedere: creaţionale, structurale sau comportamentale.
Şabloanele creaţionale (creational patterns) privesc modul de creare a obiectelor.
Şabloanele structurale (structural patterns) se referă la compoziţia claselor sau a obiectelor.
Şabloanele comportamentale (behavioral patterns) caracterizează modul în care obiectele şi clasele interactionează şi îşi distribuie responsabilităţile.
- domeniu de aplicare: şabloanele se pot aplica obiectelor sau claselor.
Şabloanele obiectelor se referă la relaţiile dintre obiecte, relaţii care au un caracter dinamic.
Şabloanele creaţionale ale obiectelor acoperă situaţiile în care o parte din procesul creării unui obiect cade in sarcina unui alt obiect.
Şabloanele structurale ale obiectelor descriu căile prin care se asamblează obiecte.
Şabloanele comportamentale ale obiectelor descriu modul în care un grup de obiecte cooperează pentru a îndeplini o sarcină ce nu ar putea fi efectuată de un singur obiect.
Şabloanele claselor se referă la relaţii dintre clase, relaţii stabilite prin moştenire şi care sunt statice (fixate la compilare).
36
Şabloanele creaţionale ale claselor acoperă situaţiile în care o parte din procesul creării unui obiect cade in sarcina subclaselor.
Şabloanele structurale ale claselor descriu modul de utilizare a moştenirii în scopul compunerii claselor.
Şabloanele comportamentale ale claselor utilizează moştenirea pentru descrierea unor algoritmi şi fluxuri de control.
Şabloanele de proiectare rezolvă multe din problemele zilnice cu care se confruntă proiectanţii. Câteva din aceste probleme sunt următoarele:
Găsirea obiectelor adecvate
Aşa cum se ştie, un obiect include atât date, cât şi metode (operaţii) care operează asupra datelor. Obiectul execută o operaţie când primeşte o cerere (mesaj) de la un client. Mesajele reprezintă singura cale prin care un obiect este determinat să execute o operaţie, în timp ce operaţiile sunt singurul mod de a modifica datele interne ale obiectului. Din cauza acestor restricţii starea internă a obiectului se spune că este încapsulată: ea nu poate fi accesată direct, iar reprezentarea ei este invizibilă dinspre exteriorul obiectului.
Partea dificilă în proiectarea unui sistem OO este descompunerea sistemului în obiecte. Aceasta deoarece procesul este influenţat de mai mulţi factori care acţionează adesea în mod contradictoriu: încapsularea, granularitatea, dependenţele, flexibilitatea, performanţele, evoluţia, gradul de reutilizare etc.
Multe din obiectele care apar la proiectare provin din modelul creat în faza de analiză. Dar, pe parcurs, la proiect se vor adăuga şi clase care nu au corespondenţe în lumea reală. Unele din aceste clase sunt de nivel primar (de ex. tablourile). Altele au un nivel de abstractizare mai ridicat. Şablonul Composite introduce o abstracţiune menită să asigure tratarea uniformă a obiectelor care nu au un corespondent fizic. Modelarea strictă a lumii reale va duce la un sistem care reflectă realitatea curentă, dar nu neapărat şi pe cea viitoare. Abstracţiunile identificate în timpul proiectării sunt esenţiale în obţinerea unui sistem flexibil. Şabloanele ne pot ajuta în identificarea unor abstracţiuni mai puţin evidente şi a obiectelor care le pot reprezenta. De exemplu, obiectele care reprezintă procese sau algoritmi nu apar în natură, dar ele nu pot lipsi dintrun proiect. Şablonul Strategy descrie modul de implementare a unor familii interschimbabile de algoritmi. Şablonul State reprezintă fiecare stare a unei entităţi sub forma unui obiect. Asemenea obiecte sunt rareori descoperite în timpul analizei sau chiar a stadiului incipient al proiectării.[6]
37
Determinarea granularităţii obiectelor
Obiectele ce compun un sistem pot varia "îngrozitor" ca mărime şi număr. Ele pot reprezenta practic orice: de la componente hardware până la aplicaţii întregi. Este dificil de stabilit unde trebuie să se "oprească" un obiect. Există şabloane care acoperă şi acest aspect. Astfel, şablonul Facade descrie modul în care subsistemele complete pot fi reprezentate ca obiecte, iar şablonul Flyweight arată cum se poate gestiona un număr uriaş de obiecte la nivelele cele mai fine de granularitate. Alte şabloane descriu căile prin care un obiect poate fi descompus în obiecte mai mici. Abstract Factory şi Builder reprezintă obiecte a căror unică responsabilitate este crearea de alte obiecte. Visitor şi Command reprezintă obiecte a căror unică responsabilitate este implementarea unui mesaj către alt obiect sau grup de obiecte.[6]
Specificarea interfeţelor obiectelor
Pentru fiecare operaţie declarată întrun obiect se precizează numele, obiectele pe care le ia ca parametri şi valoarea returnată; aceste elemente formează semnătura operaţiei. Multimea tuturor semnăturilor corespunzătoare operaţiilor dintrun obiect reprezintă interfaţa obiectului. Interfaţa unui obiect descrie complet setul mesajelor care pot fi trimise spre obiectul respectiv.
Un tip este un nume utilizat pentru a referi o anumită interfaţă. Astfel, vom spune despre un obiect că este de tipul Window dacă el acceptă toate mesajele corespunzătoare operaţiilor definite în interfaţa numită Window. Ca urmare, un obiect poate avea mai multe tipuri, adică o parte a interfeţei sale poate fi de un tip, iar alta parte - de alt tip. De asemenea, mai multe obiecte pot partaja un anumit tip comun, dacă interfeţele lor includ tipul respectiv. Interfeţele pot să conţină, la rândul lor, alte interfeţe ca submulţimi. O interfaţă nu dă nici un detaliu relativ la implementarea unui obiect, iar obiecte distincte pot implementa în mod diferit o aceeaşi cerere. Sau, altfel spus, două obiecte având implementări complet diferite pot avea interfeţe identice.[6]
Când o cerere este trimisă unui obiect, operaţia care se va executa depinde de
cerere
obiectul care recepţionează cererea.
Specificarea implementării obiectelor
Implementarea unui obiect este definită prin intermediul clasei obiectului. Clasa unui obiect specifică datele interne ale obiectului şi definiţiile operaţiilor pe care acesta le poate executa.
38
Obiectele sunt create prin instanţierea unei clase; se mai spune că un obiect este o instanţă a unei clase. Procesul de instanţiere a unei clase presupune alocarea de memorie pentru datele interne ale obiectului respectiv şi asocierea operaţiilor cu aceste date. O clasă poate fi instanţiată de mai multe ori, în felul acesta rezultând mai multe exemplare similare de obiecte.
Pe baza unor clase existente se pot defini noi clase, folosind moştenirea claselor. O subclasă moşteneşte de la una sau mai multe clase părinte (superclase) toate datele şi operaţiile definite în acestea din urmş. Obiectele instanţe ale subclasei:
vor conţine toate datele definite în subclasă şi în clasele părinte
vor putea executa toate operaţiile definite în subclasă şi în clasele părinte.
O clasă abstractă are drept scop principal definirea unei interfeţe comune pentru subclasele sale. Implementarea operaţiilor unei clase abstracte este "pasată" parţial sau în întregime subclaselor sale. De aceea, o clasă abstractă nu poate fi instanţiată. Operaţiile declarate întro clasă abstractă, dar neimplementate se numesc operaţii abstracte. Clasele care nu sunt abstracte se numesc clase concrete.
O subclasă poate detalia sau redefini comportamentul claselor părinte. Mai precis, subclasa poate redefini (override) o operaţie care apare şi întro clasă părinte, ceea ce permite subclasei să poată prelua cereri în locul superclasei.
O clasă mixin este o clasă care are drept scop oferirea unei interfeţe sau a unei funcţionalităţi opţionale altor clase. Ea este similară unei clase abstracte, în sensul că nu poate fi instanţiată, dar nu poate figura singură ca părinte al unor subclase, ci doar întro schemă de moştenire multiplă.[6]
2.2.1 Şablonul Command Şablonul Command pune la dispoziţia programatorului o modalitate de
implementare a unei acţiuni pentru un singur obiect şi pentru fiecare situaţie în care obiectul se află şi execută o acţiune.
Acesta permite clientului să satisfacă cererea venită (să execute o acţiune) fără a cunoaşte detaliile acţiunii care va fi făcută şi ,de asemenea, permite operarea oricărui tip de schimbare în ceea ce priveşte răspunsul cererii fără a afecta în niciun fel programul client.[1]
39
Acest şablon oferă o interfaţă standard pentru manipularea cererilor utilizatorilor. Fiecare cerere este încapsulată întrun obiect numit comandă. Figura de mai jos (Figură 2.2.1-1) arată care sunt clasele implicate în şablonul Command.[10]
Clasa Command reprezintă încapsularea unui singur comportament. Fiecare comportament în aplicaţie va fi modelat în funcţie de ceea ce vrem să facă respectiva comandă: salvare, ştergere, ieşire, colorare etc.
Componenta CommandManager este responsabilă pentru acordarea accesului la comenzile disponibile din aplicaţie.
Ultima componentă, Invoker, are responsabilitatea executării efective a comenzii.[10]
Exemplu: Să considerăm un program simplu care ne permite să alegem din meniu opţiunile File, Open a File şi Exit şi în fereastra de afişare să existe un buton a cărui acţiune este colorarea ferestrei în roşu(Figură 2.2.1-2).[1]
Figură 1-1
Figură 1-2
40
Efectuare unui click pe acest buton sau pe butonul de meniu va avea ca efect declanşarea unui eveniment de tipul actionPerformed având următorul cod:
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if(obj == mnuOpen)
fileOpen(); //deschidere fişier
if (obj == mnuExit)
exitClicked(); //ieşire din program
if (obj == btnRed)
redClicked(); //colorare în roşu
}
Cele trei comenzi sunt implementate astfel:
private void exitClicked() {
System.exit(0);
}
private void fileOpen() {
FileDialog fDlg = new FileDialog(this, "Open a file",
FileDialog.LOAD);
fDlg.show();
}
private void redClicked() {
p.setBackground(Color.red);
}[1]
Deoarece într-un program putem avea foarte multe butoane şi meniuri este de preferat ca fiecare buton să aibă propria sa apelare a interfeţei Command. Acest lucru duce şi la mai bună funcţionalitate a programului, dar şi la un cod mai uşor de întreţinut şi modificat.
41
În exemplul de mai jos am creat mici clase care implementează interfaţa ActionListener.
class btnRed implements ActionListener {
public void actionPerformed(ActionEvent e) {
p.setBackground(Color.red);
}
}
class fileExit implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
Acestea au fost înregistrate cu proprietatea listener în mod obişnuit.
mnuOpen.addActionListener(new fileOpen());
mnuExit.addActionListener(new fileExit());
btnRed.addActionListener(new btnRed());[1]
Pentru a reduce spaţiul de nume ocupat în memorie se declară o instanţă a acestei interfeţe direct în locul unde avem nevoie:
btnRed.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
p.setBackground(Color.red); }
} );[1]
În aplicaţia Series_Analysis şablonul Command este exemplificat şi implementat în fiecare clasă care are ca principal scop afişarea unei ferestre pe care sunt puse elemente grafice, printre care şi butoane (JButton).
Pentru exemplificare o să folosesc fereastra Serie_Analysis – pentru clienţi, unde am folosit implementarea prin unnamed inner class, fără să mai creez o clasă
42
specială pentru comandă, ci am declarat o instanţă ActionListener în locul unde am folosit butonul.
Aici se găsesc două entităţi care au acţiuni: butonul Export şi lista de metode (Figură 3.1.1-1). Lista de metode are ca efect afişarea graficului datele din sistem şi metoda de analiză aleasă în prealabil, iar butonul Export va va deschide fereastra care permite alegerea opţiunilor de printare/export (Figură 3.1.2.-1).
Implementarea butonului Export:
private void bexpActionPerformed(java.awt.event.ActionEvent evt) {
try {
new IOData().printData(txtpoza); }
catch (PrinterException ex) {
new ErrMsg().init_GUI(ex.toString()); }
}
Implementarea acţiunii listei de metode:
private void cbmethodsActionPerformed(java.awt.event.ActionEvent evt) {
if( Data_File.nrmatrix>0){
this.run(); }
else { ; }
}
......
public void run(){
if(cbmethods.getSelectedIndex()==0){
ImageIcon icon=new ImageIcon("C:\\Series_Analysis\\ ResourceFiles\\ Grafic.JPG");
txtpoza.setIcon(icon); }
else{
txtpoza.removeAll();
43
new ActionMethod().setActMethod(cbmethods.getSelectedIndex(), cbmethods.getSelectedIndex()+"");
ImageIcon icon= new ImageIcon("C:\\Series_Analysis\\graphics\\ Grafic_Picture"+cbmethods.getSelectedIndex()+".PNG");
if(icon.getIconHeight()<1){
icon= new ImageIcon("C:\\Series_Analysis\\ResourceFiles\\Grafic.JPG");
txtpoza.setIcon(icon);
new ErrMsg().init_GUI("Error on creating Graphic!\nPlease try again!");}
else{
txtpoza.setIcon(icon); }
} }
Folosirea şi implementarea interfeţei ActionPerformed nu se aplică doar în cazul entităţior jButton, plaja de utilizare fiind extinsă pentru orice entitate care poate face motivul declanşării unui eveniment. Această situaţie este exemplificată mai sus cu ajutorul obiectelor jComboBox, dar poate fi extinsă la majoritatea obiectelor grafice: meniuri, submeniuri, checkbox-uri etc.
În acest caz evenimentul îl reprezintă apelul funcţiei run() care va executa metoda selectată din lista pe care o reprezintă jComboList-ul cbmethods.
2.2.2 Şablonul Model – View - Controller Şablonul Model-View-Controller doreşte să separe o componentă sau un
subsistem în trei părţi: model, vizualizare şi control facilitând în acest fel modificarea sau implementarea fiecărui element în parte.
Un dezavantaj al acestui şablon de proiectare îl reprezintă extensibilitatea. Pentru eficacitatea codului, în privinţa reutilizării, ar trebui separate părţile componente în clase distincte: elementele de control puse întro clasă separată în vederea modificării unor operaţii şi modalităţile de afişare puse în altă clasă – deoarece putem avea mai multe reprezentări pentru acelaşi set de date (atribute al entităţii cu care lucrăm).
44
Exemplificare acestui şablon, în cele mai multe cazuri, este realizată pe o aplicaţie Swing reprezentând un sistem de logare pe un panou (jFrame).
O aplicaţie care foloseşte acest şablon trebuie să răspundă la trei întrebări: Cum modifică aplicaţia modelul? Cum sunt reflectate modificările modelului în partea de vizualizare? Cum sunt stabilite relaţiile dintre clasele modelului, vizualizării şi controlului.[1]
- Modelul poate fi orice fel de tip date acceptat de Java şi reprezintă orice fel de entitate care poate fi analizată şi proiectată.
public class Model {
private PropertyChangeSupport changeSupport= new PropertyChangeSupport(this);
private boolean loginStatus;
Figură 2-1
Figură 2-2
45
private String login;
private String password;
public Model() { loginStatus= false; }
public void setLogin(String login) { this.login= login; }
public void getPassword(String password) { this.password=password; }
public boolean getLoginStatus() { return loginStatus; } }[1]
- Partea de vizualizare este reprezentată de elementele Swing care compun părţile afişabile grafic ale aplicaţiei (interfeţe Swing: jPanel, jButton etc.)
package wrox.pattern.mvc;
import java.awt.GridLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class CenterPanel extends JPanel {
private JTextField login= new JTextField(14);
private JTextField password= new JTextField(14)
public CenterPanel() {
setLayout(new GridLayout(2, 2));
add(new JLabel(“Login:”));
add(login);
add(new JLabel(“Password:”));
add(password);
}
public String getLogin() { return login.getText(); }
public String getPassword() { return password.getText(); }
46
}[1]
- Ultimul element al şablonului Model – View – Controller îl reprezintă controlul. Acesta impune modelului comportamentul, îl controlează.
public LoginAction(Model model, CenterPanel panel ) {
this.model= model;
this.panel = panel;
}
public void actionPerformed(ActionEvent e) {
System.out.println(“Login Action: “+ panel.getLogin() +” “+ panel.getPassword());
model.login( panel.getLogin(), panel.getPassword() );
}
public class ExitAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
JFrame frame= new JFrame();
int response= JOptionPane.showConfirmDialog(frame,
“Exit Application?”, “Exit”,JOptionPane.OK_CANCEL_OPTION);
if (JOptionPane.YES_OPTION == response) { System.exit(0); }
}
}[1]
În această aplicaţie şablonul Model – View – Controller este exemplificat prin sistemul de analiză şi prelucrare de date(Figură 3.1.1-1) şi graficele care rezultă în urma analizei (Figură 3.1.8-1)deoarece datele introduse urmează un model, se pot vizualiza şi se pot controla, manipula.
Exemplul următor se referă la fereastra Series_Analysis. Pentru acestea modelul îl reprezintă o pereche denumere din fişierul încărcat în sistem, iar fiecare număr este stocat pentru moment într-o variabilă în sistem şi este accesat pentru prelucrare prin intermediul clasei Data_File.
47
package series_analysis;
/**
* @author Marius
*/
public class Data_File {
public static int nrmatrix=0;
public static String data_matrix[][] = new String[100][2];
public static int nrmethod=0;
public static String method[]= new String[30];
}
Pentru vizualizare fiecare fereastră se foloseşte de câte o clasă în care sunt implementate diferite modalităţi de afişare:
- Pentru fereastra Series Analysis o metodă de analiză şi afişare va afişa doar unele date şi un anumit grafic:
public void Gpaint(String a[][], int nrpoints, String nr) {
//paint lines
BufferedImage bi = new BufferedImage(440, 400, BufferedImage.TYPE_INT_ARGB);
Graphics2D graph = bi.createGraphics();
graph.setStroke(drawingStroke);
graph.setPaint(Color.black);
graph.draw(line1);
graph.setPaint(Color.black);
graph.draw(line2);
graph.setPaint(Color.blue);
setareAxe(a,nrpoints);
48
//y points on axe
int l3y=360;
int axay=0;
for (axay=0;axay<=11;axay++){
double yy=miny+axay*(maxy-miny)/10;
if(axay==0){
graph.draw(new Line2D.Double(18, l3y, 23,l3y)); }
else{
graph.draw(new Line2D.Double(18, l3y, 435,l3y)); }
graph.drawString(yy+"", 5,l3y-2);
l3y=l3y-30; }
//x points on axe
int l3x=20;
int axax=0;
for (axax=0; axax<=11; axax++){
double xx=minx+axax*(maxx-minx)/10;
graph.draw(new Line2D.Double(l3x, 363, l3x,358));
graph.drawString(xx+"", l3x-4,375);
l3x=l3x+40; }
//display line between points
if(Integer.parseInt(a[nrpoints-1][1])>=Integer.parseInt(a[nrpoints-2][1])){
graph.setPaint(Color.GREEN); }
else{
graph.setPaint(Color.ORANGE); }
for(int i=1; i<nrpoints; i++){
49
Line2D lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])), scalarey(Integer.parseInt(a[i-1][1])), scalarex(Integer.parseInt(a[i][0])), scalarey(Integer.parseInt(a[i][1])));
graph.draw(lin); }
//display points
for(int nrp=0;nrp<nrpoints;nrp++){
nrsx=(int) scalarex(Integer.parseInt(a[nrp][0]));
nrsy=(int) scalarey(Integer.parseInt(a[nrp][1]));
int y=nrsy;
int i=nrsx;
setPoint(graph, i,y, Integer.parseInt(a[nrp][0]), Integer.parseInt(a[nrp][1])); }
//set title and legend
......
graph.create();
//create the picture
try {
ImageIO.write(bi, "PNG", new File("C:\\Series_Analysis\\graphics\\ Grafic_Picture"+nr+".PNG")); }
catch (IOException ex) {
Logger.getLogger(Grafic.class.getName()).log(Level.SEVERE, null, ex); } (Fereastră 3.1.8-1)
- În aceeaşi fereastră se va afişa datele prin intermediul unei alte metode un alt grafic.
public void GpaintH(String a[][], int nrpoints, String nr) {
.....
graph.setPaint(Color.lightGray);
for(int i=1; i<nrpoints; i++){
50
Line2D lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])), scalarey(Integer.parseInt(a[i-1][1])), scalarex(Integer.parseInt(a[i][0])), scalarey(Integer.parseInt(a[i][1])));
graph.draw(lin);
double k = scalarey(Integer.parseInt(a[i-1][1]));
for(; k<=360; k++){
for(double k2 = scalarey(Integer.parseInt(a[i][1])); k2<=360; k2++){
lin = new Line2D.Double(scalarex(Integer.parseInt(a[i-1][0])), k, scalarex(Integer.parseInt(a[i][0])), k2);
graph.draw(lin); } }
....
graph.create();
//create the picture
}(Fereastră 2.2.2-3).
Figură 2-3
51
Partea de control se găseşte în clasa ActionMethod. Aici se găsesc toate apelurile de metode din clasele necesare prelucrării datelor încărcate, cu excepţia metodelor de vizualizare.
package series_analysis;
public class ActionMethod {
public void setActMethod(int k, String nr){
switch (k) {
case 1: new Grafic().Gpaint(Data_File.data_matrix, Data_File.nrmatrix, nr); break;
case 2: new GraficHasurat().GpaintH(Data_File.data_matrix, Data_File.nrmatrix, nr); break; }
} }
2.2.3 Şablonul Template Acest şablon face parte din categoria şabloanelor comportamentale. El se
aplică în situaţia în care se cunoaşte schema unui algoritm dar nu se cunosc paşii, ei pot să varieze, să fie diferiţi. Şablonul Template implementează într-o clasă abstractă schema algoritmului, iar paşii sunt declaraţi ca metode abstracte în această clasă, urmând a fi implementaţi diferit în subclase concrete.
Al doilea caz de utilizare îl reprezintă cazul în care mai multe clase au un comportament comun şi pentru a elimina scrierea de cod redundant, acest comportament comun se factorizează întro clasă abstractă.
Un la treilea caz de utilizare îl constituie controlul extinderii subclaselor, şi anume: se poate defini o metodă şablon care apelează aşa-numite operaţii-hook ("cârlige") în puncte specifice, permiţând astfel ca extensiile să se realizeze doar în acele puncte.[7]
Exemplele următoare vor evidenţia structura şi aplicabilitatea şablonului:
52
AbstractClass o defineşte operaţiile primitive abstracte pe care subclasele urmează să
le implementeze; o implementează o metodă şablon care defineşte scheletul unui algoritm.
Aceasta metodă apelează operaţiile primitive şi, eventual, alte operaţii definite în AbstractClass sau in alte clase:
void AbstractClass::TemplateMethod() {
PrimitiveOperation1();
PrimitiveOperation2();
}
ConcreteClass - implementează operaţiile primitive pentru a realiza paşii specifici ai algoritmului definit de TemplateMethod.[7]
Metodele şablon reprezintă o tehnica fundamentală de reutilizare a codului. Ele au o importanţă deosebită în cadrul bibliotecilor de clase, deoarece constituie un mijloc de factorizare a aspectelor comune ale comportamentului claselor respective.
Metodele şablon reprezintă o structură de control inversat. Aceasta înseamnă că o clasă părinte apelează operaţiile unei subclase şi nu invers.
Este important pentru metodele şablon să se specifice clar care operaţii sunt hook-uri (care POT fi redefinite) şi care sunt abstracte (care TREBUIE redefinite). În vederea reutilizării eficiente a unei clase abstracte, proiectanţii subclaselor ei trebuie să înţeleagă care sunt operaţiile concepute anume spre a fi redefinite. O subclasă
Figură 3-1
53
poate EXTINDE o operaţie din clasa părinte prin redefinirea acelei operaţii şi apelând explicit operaţia omonimă din părinte:
void ClasaDerivata::Operatie( ) {
//secventa specifica pt. ClasaDerivata
ClasaParinte::Operatie(); }[7]
Un alt exemplu îl constituie desenarea unor triunghiuri diferite prin forma lor.[1]
public abstract class Triangle {
Point p1, p2, p3;
public Triangle(Point a, Point b, Point c) {
p1 = a; p2 = b; p3 = c; }
public void draw(Graphics g) {
//This routine draws a general triangle
drawLine(g, p1, p2);
Point current = draw2ndLine(g, p2, p3);
Figură 3-2
54
closeTriangle(g, current); }
public void drawLine(Graphics g, Point a, Point b){
g.drawLine(a.x, a.y, b.x, b.y); }
//this routine has to be implemented
//for each triangle type.
abstract public Point
draw2ndLine(Graphics g, Point a, Point b);
public void closeTriangle(Graphics g, Point c) {
//draw back to first point
g.drawLine(c.x, c.y, p1.x, p1.y); }
}[1]
Această clasă salvează coordonatele celor trei linii, dar nu desenează decât pe prima şi pe ultima, linia a doua fiind desenată de o subclasă.
public class stdTriangle extends Triangle {
public stdTriangle(Point a, Point b, Point c)
{ super(a, b, c); }
public Point draw2ndLine(Graphics g, Point a, Point b) {
g.drawLine(a.x, a.y, b.x, b.y);
return b;
} }
public class IsocelesTriangle extends Triangle {
public IsocelesTriangle(Point a, Point b, Point c)
{ . . . }
. . . }[1]
În aplicaţia Series_Analysis şablonul Template se evidenţiază prin crearea ferestrelor care definesc ferestrele:
55
public class MainWindows extends javax.swing.JFrame {
/** Creates new form MainWindows */
public MainWindows() {
initComponents();
new Centru().CentruFereastra(this);
this.setVisible(true);
afis();
}
Aceste clase extind şi definesc în mod particular clasa jFrame.
56
2.3 Implementare Programul folosit pentru implementarea acestei aplicaţii este NetBeans 6.0.1.
Acest program are la bază limbajul de programare Java. Toate facilităţile şi instrumentele oferite de limbajul Java le regăsim şi pe platforma NetBeans.
Entitatea de bază a acestui limbaj de programare este obiectul. La nivel conceptual el este o entitate cu responsabilităţi care se află întro anumită stare, are un anumit comportament şi o identitate. La nivel de implementare el reprezintă un set de date şi metode (funcţii membre).
Obiectul este o instanţă a unei clase, ceea ce implică încărcarea atributelor datelor cu valori particulare.
Clasa este formată dintr-un grup de obiecte de acelaşi tip, este un prototip pentru mai multe obiecte şi defineşte date şi metode.
Cea mai vizibilă tehnologie folosită pentru proiectare este tehnologia Swing. Ea face parte dintrun proiect mai amplu numit JFC (Java Foundation Classes) care pune la dispoziţie o serie întreagă de facilităţi pentru scrierea de aplicaţii cu o interfaţă grafică mult îmbogăţită funcţional şi estetic faţă de vechiul model AWT. In JFC sunt incluse următoarele:
• Componente Swing
Sunt componente ce înlocuiesc şi în acelaşi timp extind vechiul set oferit de modelul AWT.
• Look-and-Feel
Permite schimbarea înfăţişării şi a modului de interacţiune cu aplicaţia în funcţie de preferinţele fiecăruia. Acelaşi program poate utiliza diverse moduri Look-and-Feel, cum ar fi cele standard Windows, Mac, Java, Motif sau altele oferite de diverşi dezvoltatori, acestea putând fi interschimbate de către utilizator chiar la momentul execuţiei .
• Accessibility API
Permite dezvoltarea de aplicaţii care să comunice cu dispozitive utilizate de către persoane cu diverse tipuri de handicap, cum ar fi cititoare de ecran, dispozitive de recunoaştere a vocii, ecrane Braille, etc.
• Java 2D API
57
Folosind Java 2D pot fi create aplicaţii care utilizează grafică la un nivel avansat. Clasele puse la dispoziţie permit crearea de desene complexe, efectuarea de operaţii geometrice (rotiri, scalări, translaţii, etc.), prelucrarea imagini, tipărire, etc.
•Drag-and-Drop
Oferă posibilitatea de a efectua operaţii drag-and-drop între aplicaţii Java şi aplicaţii native.
•Internaţionalizare
Internaţionalizarea şi localizarea aplicaţiilor sunt două facilităţi extrem de importante care permit dezvoltarea de aplicaţii care să poată fi configurate pentru exploatarea lor în diverse zone ale globului, utilizând limba şi particularităţile legate de formatarea datei, numerelor sau a monedei din zona respectivă.
Unul din principalele deziderate ale tehnologiei Swing a fost să pună la dispoziţie un set de componente GUI extensibile care să permită dezvoltarea rapidă de aplicaţii Java cu interfaţă grafică competitivă din punct de vedere comercial. Pentru a realiza acest lucru, API-ul oferit de Swing este deosebit de complex având 17 pachete în care se găsesc sute de clase şi interfeţe. Lista completă a pachetelor din distribuţia standard 1.4 este dată mai jos:
javax.accessibility
javax.swing.text.html
javax.swing.plaf.basic
javax.swing.border
javax.swing.text.rtf
javax.swing.plaf.multi
javax.swing.event
javax.swing.undo
javax.swing.text
javax.swing.plaf
javax.swing
javax.swing.text.parser
58
javax.swing.plaf.metal
javax.swing.colorchooser
javax.swing.tree
javax.swing.table
javax.swing.filechooser[4]
Evident, nu toate aceste pachete sunt necesare la dezvoltarea unei aplicaţii, cel mai important şi care conţine componentele de bază fiind javax.swing
Componentele folosite pentru crearea interfeţelor grafice Swing pot fi grupate:
• Componente atomice
JLabel, JButton, JCheckBox, JRadioButton, JToggleButton, JSlider, JProgressBar, JSeparator
• Componente complexe
JTable, JTree, JComboBox, JSpinner, JList, JFileChooser, JOptionPane
• Componente pentru editare de text
JTextField, JFormattedTextField, JPasswordField, JtextAre, JEditorPane, JTextPane
• Meniuri
JMenuBar, JMenu, JPopupMenu, JMenuItem, JcheckboxMenuItem, JRadioButtonMenuItem
• Containere intermediare
JPanel, JScrollPane, JSplitPane, JTabbedPane, JdesktopPan, JToolBar
• Containere de nivel înalt
JFrame, JDialog, JWindow, JInternalFrame, Japplet
Pentru a fi afişate pe ecran componentele grafice ale unei aplicaţii trebuie plasate pe o suprafaţă de afişare (container). Fiecare componentă poate fi conţinută doar într-un singur container, adăugarea ei pe o suprafaţă nouă de afişare determinând eliminarea ei de pe vechiul container pe care fusese plasată. Întrucât containerele pot fi încapsulate în alte containere, o componentă va face parte la un moment dat dintro ierarhie. Rădăcina acestei ierarhii trebuie să fie un aşanumit container de nivel înalt, care este reprezentat de una din clasele JFrame, JDialog sau Japplet.
59
În general orice aplicaţie Java independentă bazată pe Swing conţine cel puţin un container de nivel înalt reprezentat de fereastra principală a programului, instanţă a a clasei JFrame.
Simplificat, un obiect care reprezintă o fereastră Swing conţine o zonă care este rezervată barei de meniuri şi care este situată de obicei în partea superioară şi corpul ferestrei pe care vor fi plasate componentele.
În categoria componentelor atomice includem componentele Swing cu funcţionalitate simplă, a căror folosire este în general asemănătoare cu a echivalentelor din AWT. Aici includem:
• Etichete: JLabel
•Butoane simple sau cu două stări: JButton, JCheckBox, JRadioButton, JToggleButton; mai multe butoane radio pot fi grupate folosind clasa ButtonGroup, pentru a permite selectarea doar a unuia dintre ele.
• Componente pentru progres şi derulare: JSlider, JProgressBar, JScrollBar
• Separatori: JSeparator
•Componente pentru editare de text
•Componentele Swing pentru afişarea şi editarea textelor sunt grupate într-o ierarhie ce are ca rădăcină clasa JtextComponent din pachetul javax.swing.text.
• Text simplu pe o singură linie
– JTextField - Permite editarea unui text simplu, pe o singură linie.
– JPasswordField - Permite editarea de parole. Textul acestora va fi ascuns, în locul caracterelor introduse fiind afişat un caracter simbolic, cum ar fi ’*’.
– JFormattedTextField - Permite introducerea unui text care să respecte un anumit format, fiind foarte utilă pentru citirea de numere, date calendaristice etc. Este folosită împreună cu clase utilitare pentru formatarea textelor, cum ar fi NumberFormatter, DateFormatter, MaskFormatter etc. Valoarea conţinută de o astfel de componentă va fi obţinută/setată cu metodele getValue, respectiv setValue ¸si nu cu cele uzuale getText, setText.
• Text simplu pe mai multe linii
– JTextArea - Permite editarea unui text simplu, pe mai multe linii. Orice atribut legat de stil, cum ar fi culoarea sau fontul, se aplică întregului text şi nu poate fi specificat doar unei anumite porţiuni. Uzual, o componentă de acest tip va fi inclusă întrun
60
container JScrollPane, pentru a permite navigarea pe verticală şi orizontală dacă textul introdus nu încape în suprafaţa alocată obiectului. Acest lucru este valabil pentru toate componentele Swing pentru care are sens noţiunea de navigare pe orizontală sau verticală, nici una neoferind suport intrinsec pentru această operaţiune.
Clasa Jlist descrie o listă de elemente dispuse pe una sau mai multe coloane, din care utilizatorul poate selecta unul sau mai multe. Uzual un obiect de acest tip va fi inclus întrun container de tip JScrollPane.
Clasa JComboBox este similară cu JList, cu deosebirea că permite doar selectarea unui singur articol, acesta fiind şi singurul permanent vizibil. Lista celorlalte elemente este afişată doar la apăsarea unui buton marcat cu o săgeată, ce face parte integrantă din componentă. JComboBox funcţionează după aceleaşi principii ca şi clasa JList. Iniţializarea se face dintr-un vector sau folosind un model de tipul ComboBoxModel, fiecare element putând fi de asemenea reprezentat diferit prin intermediul unui obiect ce implementează aceeaşi intefaţă ca şi în cazul listelor: ListCellRenderer.
O diferenţă notabilă constă în modul de selectare a unui articol, deoarece JcomboBox permite şi editarea explicită a valorii elementului, acest lucru fiind controlat de metoda setEditable. Evenimentele generate de obiectele JComboBox sunt de tip ItemEvent generate la navigarea prin listă, respectiv ActionEvent generate la selectarea efectivă a unui articol.
Clasa JTable permite crearea de componente care să afişeze o serie de elemente într-un format tabelar, articolele fiind dispuse pe linii şi coloane. Un tabel poate fi folosit doar pentru afişarea formatată a unor date, dar este posibilă şi editarea informaţiei din celulele sale. De asemenea, liniile tabelului pot fi marcate ca selectate, tipul selecţiei fiind simplu sau compus, tabelele extinzând astfel funcţionalitatea listelor. Deşi clasa JTable se găseşte în pachetul javax.swing, o serie de clase şi interfeţe necesare lucrului cu tabele se găsesc în pachetul javax.swing.table, acesta trebuind aşadar importat.
În Swing, există câteva soluţii simple pentru afişarea unei imagini, cea mai utilizată fiind crearea unei etichete (JLabel) sau a unui buton (JButton) care să aibă setată o anumită imagine pe suprafaţa sa. Imaginea respectivă trebuie creată folosind clasa ImageIcon.
ImageIcon img = new ImageIcon("poza.jpg");
JLabel label = new JLabel(img); [8]
61
2.4 Explicitare claselor
About Aceasta este clasa în care este definită fereastra de mai jos
Clasa About extinde clasa javax.swing.Jframe din Java.
Aici sunt afişate câteva date despre aplicaţie şi emblema Universităţii Spiru Haret.
ActionMethod Aceasta este clasa responsabilă pentru analiza şi afişarea rezultatelor analizei conform cu metoda selectată.
Conţinutul clasei este următorul:
package series_analysis;
public class ActionMethod {
public void setActMethod(int k, String nr){
switch (k) {
case 1: new Grafic().Gpaint(Data_File.data_matrix, Data_File.nrmatrix, nr); break;
case 2: new Grafic2().Graph(Data_File.data_matrix, Data_File.nrmatrix, nr); break;}}}
În momentul când se selectează o metodă se apelează această clasă, iar parametrul k indică ce metodă să se execute.
Figură 2.4-1
62
Tot această clasă suferă modificări în procesul de update prin suprascrierea conţinutului ei.
Procesul de update se realizează astfel:
- se reţine conţinutul acestui fişier până la seria de 3 acolade }}} într-o variabilă de tip şir de caractere
- se adaugă o nouă linie (un nou case): se adaugă textul case + numărul de metode existente incrementat cu o unitate + : + comanda care va analiza datele şi le va şi afişa + ; break; şi cele 3 acolade }}}
- se va scrie conţinutul acestei variabile în acest fişier suprasciind tot conţinutul
- se va rula un fişier de tip .bat extern care execută următoarele comenzi
1. va închide aplicaţia
2. compilează această clasă
3. copiază fişierul rezultat în urma compilării în arhiva de tip .jar care este, de fapt, fişierul executabil pentru aplicaţie
În acest moment aplicaţia poate fi pornită şi se poate folosi noua metodă adăugată prin procesul descris mai sus.
BrowseFile Aceasta este clasa în care este definită fereastra pentru selectarea fişierelor care conţin datele pe care vrem să le analizăm în aplicaţie prin metodele disponibile.
Clasa BrowseFile extinde clasa javax.swing.Jframe din Java.
Apăsând butonul SelectFile se va reţine calea către fişier pentru a fi folosit ulterior pentru extragerea datelor din el.
Metoda care face acest lucru este:
private File GetPath(){
File file=filech.getSelectedFile();
return file;
}
63
BrowseUpdate Aceasta este clasa în care este definită fereastra pentru selectarea fişierelor care conţin metodele pe care vrem să le adăugăm în aplicaţie prin prin procesul de update.
Clasa BrowseUpdate extinde clasa javax.swing.Jframe din Java.
Această clasă este asemănătoare cu precedenta clasă, BrowseFile.
Apăsând butonul SelectFile se va reţine calea către fişier pentru a fi folosit ulterior pentru copierea şi prelucrarea lui.
Metoda care face acest lucru este:
private void bupdateActionPerformed(java.awt.event.ActionEvent evt) {
UpdateApp.fisiersrc=fchfile.getSelectedFile();
this.dispose();
new UpdateApp().setVisible(true);
}
Figură 2.4-2
64
După ce calea către acest fişier este reţinută, această fereastră se închide şi se va reafişa fereastra pentru update.
Centru Această clasă conţine metoda care afişează o fereastră dată ca parametru în
centrul ecranului.
public class Centru {
public void CentruFereastra(javax.swing.JFrame f){
Toolkit kit = Toolkit.getDefaultToolkit();
Dimension screenSize = kit.getScreenSize();
int latime = (int)screenSize.getWidth(); // latimea ecranului
int inaltime = (int)screenSize.getHeight(); // inaltimea ecranului
f.setLocation(((latime / 2) - (f.getWidth()/2)),((inaltime / 2) - (f.getHeight()/2)));
}}[12]
Figură 2.4-1
65
Copy_File În această clasă se află metoda care copiază fişierele de la adresa curentă în folder-ul indicat de variabila de mediu CLASSPATH pentru Java în procesul de update.
Metoda verifică dacă s-au mai selectat fişiere pentru update sau acesta este primul.
Deoarece adresele fişierelor se scriu într-un fişier .bat care se va rula ulterior este important să se ştie dacă pentru sesiunea curentă s-au mai selectat fişiere pentru update – caz în care adresele noilor fişiere selectate se vor adăuga în fişier fără ca acesta să fie suprascris sau se va suprascrie conţinutul acestui fişierului cu adresa fişierului care constituie un update.
Acest lucru se realizează prin secvenţele de cod de mai jos:
- pentru suprascriere conţinut fişier
path1= "C:\\Series_Analysis\\src\\series_analysis\\";
path1 = path1.concat(f.getName());
cpsrc="COPY \""+f.getAbsolutePath()+"\" \""+path1+"\"";
path2 = "C:\\Series_Analysis\\ResourceFiles\\Update.bat";
File copyFile = new File(path2);
new IOData().setActionMethod(copyFile, cpsrc);
- pentru adăugare adresă la fişier fără suprascriere
path1= "C:\\Series_Analysis\\src\\series_analysis\\";
path1 = path1.concat(f.getName());
cpsrc="COPY \""+f.getAbsolutePath()+"\" \""+path1+"\"";
path2 = "C:\\Series_Analysis\\ResourceFiles\\Update.bat";
File copyFile = new File(path2);
new IOData().setActionMethod(copyFile, cpsrc,1);
Diferenţa este la apelul IOData().setActionMethod(copyFile, cpsrc,1);
- dacă metoda are doar 2 parametri (fişierul cu adrese şi fişierul care se va copia) atunci fişierul cu adrese se va suprascrie.
- dacă apare şi al treilea parametru atunci se va adăuga fără suprascriere
66
Data_File Aceasta este clasa în care se reţin datele care urmează sa fie prelucrate şi afişate (în variabilele nrmatrix şi data_matrix) şi lista de metode care se pot folosi pentru analiza şi afişarea datelor.
- nrmatrix reprezintă numărul maxim de elemente care sunt încărcate în sistem, iar data_matrix lista cu aceste date
public static int nrmatrix=0;
public static String data_matrix[][] = new String[100][2];
- nrmethod reprezintă numărul de metode încărcate în sistem, iar method lista cu aceste metode
public static int nrmethod=0;
public static String method[]= new String[30];
ErrMsg Aceasta este clasa în care este definită fereastra de mai jos.
Clasa ErrMsg extinde clasa javax.swing.Jframe din Java.
Aici sunt afişate câteva erorile care apar în aplicaţie şi o iconiţă de atenţionare.
Grafic Aceasts este una dintre clasele care analizează şi afişează datele.
Folosind acestă clasă se vor afişa punctele pe ecran fără a se prelucra.
Figură 2.4-4
67
Este recomandat ca pentru toate metodele folosite să se prelucreze datele, să se depună în clasa Data_File şi să se apeleze această metodă pentru datele din clasa mai sus amintită.
În această clasă se desenează axele, punctele şi linia care uneşte aceste puncte.
Pentru că datele analizate au valori diferite – de la numere subunitare până la numere foarte mari, tot această clasă realizează o scalare a acestor numere pentru a se încadra cât mai bine în zona pentru afişare a graficului.
Fiind o proiecţie 2D cele două funcţii pentru scalarea pe axele OX şi OY sunt:
private double scalarex(int nrx){
//scale coordonate x
pasx=(maxx-minx)/400;
double nrs1x=(nrx-minx)/pasx;
nrs1x=nrs1x+x0;
return nrs1x;
}
private double scalarey(int nry){
//scale coordonate y
pasy=(maxy-miny)/300;
double nrs1y=(nry-miny)/pasy;
nrs1y=360-nrs1y;
return nrs1y;
}
Tot această clasă transformă graficul intr-un fişier .png – format imagine şi poate fi prelucrat şi vizualizat şi după ce s-a închis programul.
try {
ImageIO.write(bi, "PNG", new File (" C:\\ Series_Analysis\\ graphics\\ Grafic_Picture"+nr+".PNG"));
68
} catch (IOException ex) {
Logger.getLogger(Grafic.class.getName()).log(Level.SEVERE, null, ex);
}
Hdata Aceasta este clasa în care este definită fereastra de mai jos.
Clasa Hdata extinde clasa javax.swing.Jframe din Java.
Aici sunt afişate fişierele cu date care s-au încărcat în aplicaţie spre a fi analizate şi un buton de export al tabelului.
IOData În această clasă se realizează toate operaţiile care necesită transfer de date din fişier în aplicaţie şi invers.
Metoda get_data returnează textul dintr-un fişier linie cu linie.
public String get_data(File log_file){
.....
try {
while (( line = input.readLine()) != null){
Figură 2.4-5
69
contents.append(line);
contents.append(System.getProperty("line.separator"));
}
....
return contents.toString();
}
Metoda set_data scrie în fişier logurile şi/sau istoricul fişierelor cu date importate.
public void set_data(File log_file, String frame, String action) throws FileNotFoundException, IOException {
.......
Calendar clnd = Calendar.getInstance();
String log="\n"+clnd.getTime().toLocaleString()+"-"+frame+"-"+action+"-";
FileWriter fstream = new FileWriter(log_file, true);
BufferedWriter out = new BufferedWriter(fstream);
out.append(log);
out.close();
}
Metoda convert StringToList extrage datele din fişierele de istoric şi le inserează într-un tabel.
public void convertStringToList(File document, String separator1, String separator2, javax.swing.table.DefaultTableModel dtmtable, javax.swing.JTable tbl) {
StringTokenizer stNewLine = new StringTokenizer(text, separator1);
while (stNewLine.hasMoreTokens()) {
String line = stNewLine.nextToken();
StringTokenizer st = new StringTokenizer(line, separator2);
70
while (st.hasMoreTokens()) {
data=st.nextToken();
window=st.nextElement().toString();
action=st.nextToken().toString();
dtmtable.insertRow(nr_row++,new String[]{data,window,action} );
}
Metoda SeparatorData setează separatorul dintre date cu cel selectat din listă.
De exemplu dacă în listă este scris , (comma) se va seta separatorul „ , ”.
public String SeparatorData(String f){
String path="";
StringTokenizer stNewLine = new StringTokenizer(f, "(");
path = stNewLine.nextToken().toString();
return path;
}
Metoda printData (tabel) exportă/imprimă tabelul.
public void printData(javax.swing.JTable t) throws PrinterException{
t.print();
}
Metoda printData (label) exportă/imprimă graficul afişat într-un jLabel.
public void printData(final javax.swing.JLabel pnl) throws PrinterException{
....
pj.setPrintable(new Printable() {
public int print(Graphics pg, PageFormat pf, int pageNum) {
Graphics2D g2 = (Graphics2D) pg;
g2.translate(pf.getImageableX(), pf.getImageableY());
71
pnl.paint(g2);
return Printable.PAGE_EXISTS;
....
pj.print();
pnl.print(pnl.getGraphics());
}
Metoda setActionMethod scrie loguri în fişierele de istoric suprascriin fişierul.
public void setActionMethod(File log_file, String act) throws IOException {
FileWriter fstream = new FileWriter(log_file);
BufferedWriter out = new BufferedWriter(fstream);
out.append(act);
out.close();
}
Metoda setActionMethod cu 3 parametrii scrie loguri în fişierele de istoric adăugând la conţinutul deja existent al fişierului.
public void setActionMethod(File log_file, String act, int i)throws IOException {
FileWriter fstream = new FileWriter(log_file, true);
BufferedWriter out = new BufferedWriter(fstream);
out.append(act);
out.close();
}
Metoda getActionContent reţine conţinutul clasei ActionMethod până întâlneşte seria de 3 acolade (}}}).
public String getActionContent(String path){
String str="", s="";
StringTokenizer st = new StringTokenizer(path, "}");
72
while (st.hasMoreTokens()) {
s=st.nextToken().toString();
if(!s.equals(System.getProperty("line.separator"))){
str = str.concat(s);
}
else ;
}
return str;
}
Metoda AddMethod rescrie fişierul ActionMethod cu noile metode adăugate.
Pentru mai multe detalii privind procesul de update a se vedea secţiunea 2.4Explicitarea claselor – subsecţiunea ActionMethod.
public void AddMethod(File log_file, String name) throws FileNotFound Exception, IOException {
String log="\n"+name;
FileWriter fstream = new FileWriter(log_file, true);
BufferedWriter out = new BufferedWriter(fstream);
out.append(log);
out.close();
}
Logs Aceasta este clasa în care este definită fereastra de mai jos.
Clasa Logs extinde clasa javax.swing.Jframe din Java.
Aici este afişat istoricul accesărilor funcţionalităţilor din aplicaţie spre şi un buton de export al tabelului.
73
Main Clasa Main este clasa principală a aplicaţiei şi prin intermediul ei se apelează
majoritatea celorlalte clase. Aceasta are responsabilitatea apelării clasei care deschide practic aplicaţia.
public class Main {
public static void main(String[] args) {
new MainWindows()setVisible(true);
}
}
MainWindows Aceasta este clasa în care este definită fereastra de mai jos.
Clasa MainWindows extinde clasa javax.swing.Jframe din Java.
Aici este afişat graficul pentru datele analizate, meniul aplicaţiei, lista de metode şi un buton de imprimare/export pentru graficul generat.
Figură 2.4-6
74
Această clasă reprezintă, de fapt, fereastra principală a aplicaţiei Series Analysis.
SetData Aceasta este clasa în care este definită fereastra de mai jos.
Clasa SetData extinde clasa javax.swing.Jframe din Java.
În această clasă se află implementată funcţionalitatea de a selecta separatorul dintre datele din fişierul folosit în analiză.
Figură 2.4-7
Figură 2.4-8
75
Metoda care oferă lista de separatori de date este următoarea:
private void setSeparator(){
cbsepar.addItem(","+"(comma)");
cbsepar.addItem("|"+"(pipeline)");
cbsepar.addItem("."+"(dot)");
cbsepar.addItem("-"+"(line)");
cbsepar.addItem("_"+"(underline)");
cbsepar.addItem(" "+"(TAB)");
cbsepar.addItem(" "+"(space)");
}
UpdateApp Aceasta este clasa în care este definită fereastra de mai jos.
Clasa UpdateApp extinde clasa javax.swing.Jframe din Java.
În această clasă se află implementată funcţionalitatea de a pregăti pentru copiere/update fişierele care trebuiesc compilate şi adăugate aplicaţiei.
Tot în acestă clasă se va trimite către clasa IOData numele metodei care va fi adăugată în fişierul cu lista de metode şi apoi folosită în aplicaţie.
Figură 2.4-9
76
UserManual Aceasta este clasa în care este definită fereastra de mai jos.
Clasa UserManual extinde clasa javax.swing.Jframe din Java.
În această clasă se află implementată funcţionalitatea de a afişa manualul de utilizare al aplicaţiei şi de a-l parcurge pagină cu pagină..
Parcurgerea paginilor manualului de utilizare se face cu ajutorul slider-ului din partea de sus a ferestrei. Când cursorul ajunge în dreptul unui număr se va afişa pagina cu numărul respectiv.
Metoda care realizează acest lucru este:
private void spgStateChanged(javax.swing.event.ChangeEvent evt) {
poza = new ImageIcon("C:\\Series_Analysis\\ResourceFiles\\ UserManual\\ UserManual"+spg.getValue()+".PNG");
txtpg.setIcon(poza);
scrp.setViewportView(txtpg);
}
Figură 2.4-10
77
În acest capitol au fost prezentate şabloanele de proiectare care stau la baza realizării acestei aplicaţii.
Pe lânga aceste lucruri au fost evidenţiate şi detaliile implementării propriu-zise a aplicaţiei: cazuri de utilizare, diagrame sau explicitarea fiecărei clase în parte care compune acest proiect.
78
CAPITOLUL 3 - UTILIZARE
În acest capitol, Capitolul 3, doresc să prezint fiecare detaliu al aplicaţiei din perspectiva unui utilizator care nu cunoaşte noţiunile de matematică sau informatică prezentate în capitolele anterioare.
Acest lucru doresc să îl prezint sub forma unui manual de utilizare al aplicaţiei pentru a facilita totodată folosirea programului.
Tot în acest capitol este prezentat şi programul în care s-a dezvoltat această aplicaţie.
3.1 Manual de utilizare
3.1.1 Series_Analysis Aceasta este fereastra principală. Aici se vor alege metodele de analiză a datelor precum şi modul de afişare (graficul).
Figură 3.1.1-1
79
Această pagină dispune de un meniu – în partea superioară a ferestrei, de o listă de metode – în partea dreapă-sus, de un buton pentru exportul graficului – sub lista de metode, emblema Universităţii Spiru Haret şi numele absolventului – pe partea dreaptă a ferestrei şi zona de afişare a graficului – reprezentând cea mai mare zonă a ferestrei.
Elementele Vizuale
Meniu
Meniul File
- Submeniul Logs
Acest meniu oferă acces către secţiunea de vizualizare a logurilor. Un click pe acest meniu va deschide fereastra Logs.
De asemenea, secţiunea loguri poate fi accesată şi prin combinaţia de taste CTRL+L.
Pentru a vizualiza detalii despre loguri a se vedea secţiunea 2.5.3 View Logs.
- Submeniul History Data
Acest meniu oferă acces către secţiunea de vizualizare a istoricului datelor introduse în aplicaţie şi analizate. Un click pe acest meniu va deschide fereastra History Data.
De asemenea, secţiunea de istoric date poate fi accesată şi prin combinaţia de taste CTRL+H.
Pentru a vizualiza detalii despre istoricul datelor analizate a se vedea secţiunea 2.5.4 History Data.
- Submeniul Update
Acest meniu oferă acces către secţiunea pentru actualizarea aplicaţiei cu noi metode de analiză şi afişare a datelor . Un click pe acest meniu va deschide fereastra Update.
Figură 3.1.1-2
80
De asemenea, secţiunea pentru update poate fi accesată şi prin combinaţia de taste CTRL+U.
Pentru a vizualiza detalii despre actualizare a se vedea secţiunea 2.5.5 Update.
- Submeniul Exit
Acest meniu închide aplicaţia.
Este recomandat să se închidă aplicaşia din acest meniu şi nu din butonul deoarece procedura care închide aplicaţia este în strânsă legătură cu cea de update, actualizarea realizându-se doar cand aplicaţia este oprită. De asemenea, ieşirea din aplicaţie se poate face şi prin combinaţia de taste CTRL+E.
Meniul Analysis
- Submeniul Chart
Acest meniu oferă acces către secţiunea de vizualizare a datelor sub forma unui grafic. Un click pe acest meniu va activa lista cu metode aflată în partea dreaptă a ferestrei. De asemenea, secţiunea grafic poate fi accesată şi prin combinaţia de taste CTRL+G.
Pentru a vizualiza detalii despre grafice a se vedea secţiunea 2.5.8 Grafice.
- Submeniul Data
Acest meniu oferă acces către secţiunea de încărcare a datelor în aplicaţie pentru a fi analizate. Un click pe acest meniu va deschide fereastra Load Data. De asemenea, secţiunea de istoric date poate fi accesată şi prin combinaţia de taste CTRL+S.
Pentru a vizualiza detalii despre încărcarea datelor în aplicaţie a se vedea secţiunea 2.5.7 Load Data.
Figură 3.1.1-3
81
Meniul Help
- User Manual
Acest meniu oferă acces către secţiunea de vizualizare a manualului de utilizare a aplicaţiei. Un click pe acest meniu va afişa o fereastră în care se poate consulta manualul pentru utilizarea aplicaţiei.
Pentru a vizualiza detalii despre manual de utilizare a se vedea secţiunea 2.5.9 User Manual.
- About
Acest meniu oferă acces către secţiunea de informare asupra acestui program. Un click pe acest meniu va deschide fereastra About.
Pentru a vizualiza detalii despre această pagină a se vedea secţiunea 2.5.10 About.
Metode
După ce datele au fost încărcate în sistem se accesează meniul Chart.
În acest moment lista de metode devine accesibilă şi se populează cu numele fiecărei metode care poate fi folosită în aplicaţie.
Dacă numele metodei se va modifica în fişierul care conţine numele metodelor, atunci acest lucru va fi vizibil la un nou eveniment care conduce la repopularea listei cum ar fi o nouă accesare a meniului Chart sau o repornire a aplicaţiei.
Dacă se modifică numărul de metode sau ordinea lor în fişierul care conţine lista de metode atunci impactul acestor modificări se reflectă în funcţionalitatea aplicaţiei astfel:
Figură 3.1.1-4
Figură 3.1.1-5
82
- dacă de modifică ordinea se va folosi o altă metodă pentru acest nume deoarece în aplicaţie metodele nu pot fi interschimbate între ele.
- dacă se vor elimina nume de metode funcţionalităţile metodelor respective nu vor mai putea fi folosite deşi ele încă există în aplicaţie.
- dacă se vor adaugă nume de metode noi în acest fişier,acestea ve vor afla în lista de metode, dar în momentul folosirii vor genera un mesaj de eroare şi nu se va face analiză şi vizualiza de date. Pentru mai multe detalii despre eroarea generată a se vedea secţiunea 2.5.11 Eroare.
Export
După alegerea metodei şi generarea graficului acesta se poate imprima sau exporta în fişier. Pentru acest lucru se apasă butonul Export.
Pentru mai multe detalii despre export se vedea secţiunea 2.5.2 Export
Alte elemente grafice
În partea dreaptă a ferestrei sunt afişate emblema Universităţii Spiru Haret şi, dedesubt, numele absolventului.
Aceste elemente un se pot edita sau schimba.
Figură 3.1.1-6
83
Cea mai mare parte a ferestrei este ocupată de grafic.
Aici sunt afişate graficele generate de toate metodele disponibile în aplicaţie.
Pentru detalii privind generarea şi afişarea unui grafic a se vedea secţiunea 2.5.8 Grafice.
3.1.2 Export Apăsarea butonului Export are ca efect afişarea unei ferestre cu opţiuni de imprimare.
Figură 3.1.1-7
84
Aici se va alege ca imprimantă numele doPDF v7 şi se apasă butonul OK.
doPDF este un produs software extern adiţional aplicaţiei care permite printarea fişierelor în fişier de tip pdf.
Acest tip de fişiere se pot deschide cu programul Adobe Reader.
Aceste două programe, doPDF şi Adobe Reader trebuiesc instalate odată cu instalarea acestui program pentru a beneficia de exportul şi vizualizarea datelor întrun fişier cu extensia pdf.
După apăsarea butonului Ok va apărea o fereastră cu opţiuni ale programului doPDF.
Figură 3.1.2-1
85
Aici se poate alege calea şi numele fişierului în care va fi salvat graficul prin accesarea butonului Browse.. sau prin editarea câmpului File name.
De asemenea pot fi utilizate şi alte opţiuni precum folosirea implicită a unui folder pentru salvarea fişierelor sau deschiderea automată a unui fişier atunci când a fost generat.
Pentru generarea fişierului se apasă butonul OK.
Figură 3.1.2-2
86
3.1.3 View Logs Aceasta este pagina în care se poate vizualiza istoricul accesărilor paginilor şi al funcţionalităţilor din acest proiect.
În această pagină se pot vizualiza datele sub forma unui tabel care conţine 3 coloane:
- prima coloană (Date/Time) afişează data şi ora la care s-a produs evenimentul
- a doua coloană (File) afişează numele ferestrei în care s-a produs evenimentul înregistrat
- a treia coloană (Path) reprezintă evenimentul înregistrat
Coloanele nu se pot edita sau sorta, dar se pot interschimba între ele. Implicit sortarea datelor se face după data înregistrării evenimentelor.
Figură 3.1.2-3
87
Apăsarea butonului Export are ca efect printarea sau salvarea istoricului accesărilor în fişier.
Pentru mai multe detalii despre export a se vedea secţiunea 2.5.2 Export.
3.1.4 History Data Aceasta este pagina în care se poate vizualiza istoricul fişierelor cu date importate în proiect.
În această pagină se pot vizualiza datele sub forma unui tabel care conţine 3 coloane:
- prima coloană (Date/Time) afişează data şi ora la care s-a încărcat fişierul
- a doua coloană (File) afişează numele fişierului care s-a încărcat
- a treia coloană (Path) reprezintă cale fişierului încărcat
Coloanele nu se pot edita sau sorta, dar se pot interschimba între ele. Implicit sortarea datelor se face după data încărcării fişierelor în sistem.
Figură 3.1.3-1
88
Apăsarea butonului Export are ca efect printarea sau salvarea istoricului încărcărilor de date în fişier.
Pentru mai multe detalii despre export a se vedea secţiunea 2.5.2 Export.
3.1.5 Update Aceasta este pagina în care se pot încărca fişiere cu noi funcţionalităţi în proiect.
Pentru a putea adăuga noi funcţionalităţi aplicaţiei trebuie adăugat fişierul(e) care le conţin. Pentru acest lucru se apasă butonul Browse.
Acesta are ca efect ascunderea acestei ferestre şi afişarea unei alte ferestre care permite selectarea fişierului.
Pentru mai multe detalii privind selecţia fişierelor a se vedea secţiunea 2.5.6 Browse.
Figură 3.1.4-1
Figură 3.1.5-1
89
După selectarea fişierului această fereastră va reapărea cu rumătoarele modificări:
- în partea dreaptă a câmpului Source File se va afişa calea către fişier.
- butonul Update va fi accesibil
Dacă checkbox-ul din stânga butonului Update este bifat atunci câmpurile Method Name şi Command se vor activa şi vor putea fi editate.
Aici se vor completa numele metodei şi comanda în limbajul de programare java care va analiza şi afişa graficul.
În cazul în care sunt mai multe fişiere care trebuiesc încărcate nu se va bifa acest checkbox. Fişierul care conţine comanda se va încărca ultimul.
După ce fişierul este gata pentru a fi uploadat în sistem se apasă butonul Update.
Procedura se repetă pentru fiecare fişier care trebuie încărcat.
3.1.6 Browse Aceasta este pagina în care se pot selecta fişierele care urmează a fi folosite în proiect.
Figură 3.1.5-2
90
După apăsarea oricărui buton Browse se va afişa o fereastră care permite selectarea unui fişier pentru a fi utilizat în aplicaţie.
După ce fişierul a fost selectat se apasă butonul Select File.
3.1.7 Load Data Aceasta este pagina în care se pot selecta fişierele care conţin datele pentru a fi analizate în proiect.
Figură 3.1.6 -1
Figură 3.1.7-1
91
Pentru a putea încărca datele in aplicaţie trebuie adăugat fişierul care le conţine. Pentru acest lucru se apasă butonul Browse.
Acesta are ca efect ascunderea acestei ferestre şi afişarea unei alte ferestre care permite selectarea fişierului.
Pentru mai multe detalii privind selecţia fişierelor a se vedea secţiunea 2.5.6 Browse.
După reapariţia ferestrei se va afişa numele fişierului, iar butonul Separator se va activa
Următorul pas este alegerea separatorului de date.
Se alege separatorul din listă şi se apasă butonul Separator.
Acum se activează şi butonul Load Data şi se dezactivează Separator şi lista de separatori.
După ce fişierul este gata pentru a fi uploadat în sistem se apasă butonul Load Data.
Dacă se doreşte analiza mai multor seturi de date procedura se repetă pentru fiecare fişier care trebuie încărcat.
Figură 3.1.7-2
Figură 3.1.7-3
92
3.1.8 Grafice Analiza şi afişarea graficelor se realizează în fereastra Series Analysis.
După ce a fost încărcat în sistem fişierul cu date se alege din meniul Analysis submeniul Chart.
Se alege metoda de analiză din lista de metode disponibile şi graficul se va afişa automat.
Dacă apar erori în aplicaţie în procesul de analiză sau/şi afişare a datelor se va afişa o fereastră care vă va informa asupra acestui lucru precum şi cauza erorii.
Pentru mai multe detalii privind afişarea erori a se vedea secţiunea 2.5.11 Eroare.
3.1.9 User Manual Accesarea meniului Help, submeniul User Manual va deschide o fereastră în care poate fi vizualizat manualul de utilizare al aplicaţiei.
Figură 3.1.8-1
93
În partea superioară a ferestrei de află un slider care permite vizualizarea paginilor din document.
Pentru a se ajunge la o anumită pagină se va trage cu mouse-ul de până se ajunge în dreptul numărului pagini respective.
Pentru a se putea vizualiza şi informaţiile din partea inferioară a paginii se va utiliza bara de defilare aflată în partea dreaptă a ferestrei.
3.1.10 About Accesarea meniului Help, submeniul About va deschide o fereastră în care se pot vizualiza câteva detalii despre această aplicaţie.
Figură 3.1.9-1
Figură 3.1.10-1
94
3.1.11 Eroare Dacă apare o eroare în aplicaţie aceasta este semnalată către utilizator prin intermediul unei ferestre.
Aceste erori pot fi:
- nu se poate genera graficul
- nu se poate citi fişierul cu date
- nu se pot citi fişierele cu istorice
- nu se poate citi fişierul cu metode
- nu se pot încărca fişiere pentru actualizare
Figură 3.1.11-1
95
3.2 NetBeans IDE 6.8
Primul program pe care l-am folosit pentru dezvoltarea aplicaţiei a fost NetBeans IDE 6.8. Această aplicaţiei dezvoltată de firma SUN mi-a permis să creez clasele şi ferestrele folosite în întreaga aplicaţie.
Pentru a folosi, a accesa aplicaţia se execută dublu click pe
iconiţa de pe desktop creată automat de program la instalare,
asemănătoare cu cea afişată în partea dreaptă.Aceasta va avea ca efect deschiderea ferestrei principale:
Figură 3.2-1
Figură 3.2-2
96
În partea de sus a ferestrei (Figură 3.2-2) se află bara de meniuri.
Sub aceasta găsim o altă bară, cu instrumente care ne ajută să efectuăm anumite operaţii fără a căuta comanda pentru acestea în bara de meniuri
În partea stângă a ferestrei se află un grup de ferestre care ne arată fişierele deschise (clasele), pentru fiecare clasă ne indică atributele şi metodele existente, conexiunea cu baza de date şi alte lucruri pe care noi dorim să le vizualizăm. Deoarece putem modifica ferestrele pe care dorim să le vedem, putem alege să nu vizualizăm nici una prin închiderea lor.
Pe partea dreaptă, reprezentâmd cea mai mare fereastră, este fereastra de lucru. Aici se vor deschide ferestrele în care putem edita codul pentru fiecare clasă şi crearea, prin intermediul unei interfeţe, a ferestrelor create de utilizatori pentru dezvoltarea propriilor aplicaţii.
În partea de jos găsim un alt grup de ferestre pentru afişare: prima fereastră, utilizată cel mai des, este cea pentru afişările din timpul rulării programului (afişări impuse de utilizator, erori etc). Această fereastră poate fi închisă, însă se va deschide automat la o nouă rulare a programului; dar pot fi deschise mai multe astfel de ferestre în cazul unor rulări succesive, fără a închide sau a aştepta terminarea execuţiei aplicaţiei.
A doua fereastră este fereastra pentru afişările din timpul rulării testelor JUnit pentru ferestrele testate. Această fereastră are aceleaşi caracteristici ca şi precedenta.
Pentru a realiza o nouă aplicaţie se va selecta din meniul File opţiunea „New Project...” şi va apărea fereastra de mai sus. Aceasta ne permite alegerea unui tip de aplicaţie din mai multe categorii puse la dispoziţie. Cele mai folosite sunt categoriile „Java” cu proiectul „Java Application” şi „Web” cu proiectul „Web Application”.
Figură 3.2-3
Figură 3.2-4
97
După ce am ales categoria si proiectul în care se încadrează aplicaţia noastră se apasă pe butonul „Next >”.Efectul acestui buton va fi deschiderea ferestrei de mai jos.
Aceasta ne permite să introducem numele proiectului precum şi locul pe disc unde îl salvăm (Figură 3.1-6).
Figură 3.2-5
Figură 11-6
98
După ce am introdus aceste date se apasă pe „Finish”. Acum putem începe să construim şi să implementăm clasele aplicaţiei.
Pentru a crea o nouă clasă, sau fereastră se apasă click-ul din dreapta al mouse-lui pe pachetul creat cu numele dat de noi, se alege opţiunea „New”, iar apoi ceea ce vrem să creem (Figură 3.1-8).
Figură 3.2-7
Figură 3.2-8
99
După ce am ales ce vrem să obţinem se va afişa o fereastră care ne cere să introducem date legate de numele clasei (a ferestrei sau a ceea ce am ales pentru creare) şi locaţia acesteia, după care se apasă pe butonul „Finish”.
Dacă am ales să obţinem ca rezultat o fereastră, o putem popula cu diferite obiecte prin interfaţa pusă la dispoziţie de NetBeans: în partea dreaptă va apărea un grup de ferestre suprapuse care ne oferă posibilitatea alegerii obiectelor (butoane, câmpuri de text etc) cu un click şi punerea lor pe fereastra pe care dorim să o afişăm la final, reprezentată de un chenar de culoare gri.
Figură 3.2-9
Figură 3.2-10
100
Figură 3.2-12
În cazul în care dorim să implementăm acţiunile unor obiecte alegem, din partea superioară a ferestrei din centru, opţiunea „Source” şi vom comuta pe „Design” doar dacă vrem să facem modificări asupra elementelor afişate pe fereastră, fără a scrie noi codul sursă necesar.
După ce am creat clasele care compun aplicaţia putem alege opţiunea realizării unui test pentru fiecare clasă în vederea asigurării corectitudinii implementării acesteia.
Pentru acest lucru se face click dreapta pe clasa dorită să se testeze, se alege opţiunea „Tools”,iar de aici „Create JUnit Tests” (Figură 3.1-12).
După ce am ales această opţiune se va afişa o fereastră care ne oferă posibilitatea alegerii unor opţiuni legate de modul de testare al clasei testate.
De cele mai multe ori aceste opţiuni sunt lăsate bifate cum au apărut când s-a deschis fereastra (rămân în modul „Default”). La final, fie că se fac modificări, fie că nu, se apasă butonul „OK” (Figură 3.1-13).
Figură 3.2-11
101
Figură 3.2-13
Efectul acestui buton este deschiderea ferestrei iniţiale (pentru realizarea implementărilor), dar va avea în plus şi fereastra de test creată automat. În acest fel putem implementa orice test de verificare dorim şi vizualizarea rezultatelor testului (după compilare şi rulare).
Figură 3.2-14
102
Pentru închiderea aplicaţiei se apasă butonul aflat în colţul din dreapta sus al ferestrei care defineşte spaţiul de afişare al programului NetBeans.
O altă posibilitate este accesarea meniului „File” şi de aici apăsăm pe opţiunea „Exit”.
În ambele cazuri trebuie să salvăm tot ceea ce s-a lucrat până atunci. Dacă nu s-a efectuat salvare până în acel moment se va afişa o fereastră de avertizare. Aceasta ne oferă posibilitatea salvării, închiderii programului fără salvare sau întoarcerii la fereastrele de lucru deschise anterior în cadrul proiectului.[16]
Figură 3.2-15
103
CONCLUZII
Analiza Seriilor reprezintă un proiect care nu se încheie odată cu susţinerea acestui examen, ci el va continua să fie dezvoltat de viitorii masteranzi ai Universităţii Spiru Haret care vor dori să studieze mai mult domeniul seriilor de timp.
Având ca principal scop o continuitate didactică, acest proiect va fi îmbunătăţit şi actualizat cu noi modele şi metode de către studenţii universităţii.
În primul capitol sunt prezentate aspectele matematice care stau la baza acestui program şi care pot sta, de asemenea, la baza dezvoltării ulterioare a unor noi metode sau modele de analiză şi afişare grafică a seriilor de timp. Printre altele, aici sunt prezentate două modele de extragere a trendului, precum şi câteva modele de serii de timp – care pot reprezenta obiectul unui update ulterior al acestui program.
În al doilea capitol sunt prezentate fundamentele proiectării şi implementării acestui proiect, precum şi explicitarea claselor constituente. Aici sunt prezentate trei şabloane de proiectare care au contribuit la dezvoltarea aplicaţiei.
În ultimul capitol, capitolul trei, se regăseşte manualul de utilizare al aplicaţiei şi o scurtă prezentare a programului în care am dezvoltat acest proiect. Acest capitol are rolul de a facilita înţelegerea folosirii aplicaţiei, dar şi de a îndruma persoanele care doresc continuarea acestui proiect pentru a dezvolta noile facilitati cat mai uşor în clase Java prin intermediul programului Net Beans.
104
BIBLIOGRAFIE
1. Cooper J. The Design Patterns Java Companion [Carte]. - Reading : Addison-Wesley, 1998.
2. Couch J., Seinberg, D. Java 2 Enterpise Edition Bible [Carte]. - New York : Hungry Minds, 2002.
3. Eckstein R., Loy, M., Wood, D. Java Swing [Carte]. - Sebastopol : O'Reilly, 2001.
4. Frăsinaru C. Curs practic de Java [Carte].
5. Gallardo D. Java design patterns 101 [Carte].
6. LOOSE Project labs.cs.utt.rodocDPDP02.html. – Timişoara, 2008.
7. LOOSE Project labs.cs.utt.rodocDPDP10.html. – Timişoara, 2008.
8. Morrison M. Java 2 GUI Fundamentals with Swing [Carte]. - [s.l.] : DigitalThink, 1999.
9. Reese G. Database Programming with JDBC and Java [Carte]. - Sebastopol : O'Reily, 2001.
10. Richardson C., Avondolio, D., Schrager, S., Mitchell, M., Scanlon, J. Professional Java JDK 6 Edition [Carte]. - Indianapolis : Wiley Publishing, 2007.
11. Robinson M., Vorobiev, P. Swing Second Edition [Carte]. - Greenwich : Manning, 2003.
12. sim085 forum.java.sun.comforum.jspaforumID=57&start=0.mht. - 2005.
13. Tanasă Şt., Olaru, C., Andrei, Şt. Java de la 0 la expert [Carte]. - Iaşi : Polirom, 2003.
14. Dumitru M. Comerţul Electronic – Lucrare de Licenţă – Piteşti, 2008.
15. www.sun.com NetBeans 6. - [s.l.] : Sun, 2008.
105
16. http://java.sun.com/docs/books/tutorial/uiswing/components/ Swing elements – [s.l.] : Sun, 2010
17. Ruey S. Tsay Analysis of Financial Time Series – Canada : John Wilei & Sons, Inc, 2002
18. www.csa-isc.ro
19. Voineagu V., Radu Şerban Teorie şi practică econometrică – Bucureşti : Meteor Press, 2007
20. Pârţachi I Prognoza seriilor cronologice cu metode traditionale, econometrice si modificarile lor – Bucureşti : ASE, 2003
21. Nicolescu O., Verboncu I. Metodologii manageriale – Bucureşti: Tribuna Economică, 2001
22. Richard J. Povinelli Time series data mining: identifying temporal patterns for characterization and prediction of time series events – Milwaukee: Milwaukee, 1999
