Curent electric -mișcarea ordonată a particulelor cu sarcină electrică în câmp electric. Intensitatea curentului electric este o mărime fizică scalară definită ca raportul dintre sarcina el…Full description
Conspect teorie macroeconomie. notiuni teoretice.
Teorie informatica pentru BACFull description
Teorie Si Analiza Gramaticala
sintesi schematica delle teorie sul totalitarismo di Hannah Arendt, Friedrich e Brzezinski
Full description
1.Ce este Java un limbaj de programare, programare , ale cărui calităţi i-au permis răspândirea rapidă, fiind în prezent unul din limbajele cele mai larg folosite. un mediu de execuţie pentru execuţie pentru aplicaţiile Java, numit în prezent în engleză engleză "Java 2 Runtime Environment" , care conţine maşina virtuală Java şi un nucleu al bibliotecilor de clase Java; o platformă pentru dezvoltarea de aplicaţii în care se foloseşte limbajul Java, care se numeşte în prezent în engleză "Java 2 Platform" ş i conţine: o compilatorul Java ( Java Compiler ); ); o maşina virtuală Java ( Java Virtual Machine ); o bibliotecile de clase Java ( Java Class Libraries ); o vizualizatorul de appleturi Java ( Java AppletViewer ); ); o depanatorul Java ( Java Debbuger ) şi alte instrumente de dezvoltare; o documentaţia; o tehnologie software puternică software puternică şi modernă, care corespunde cerinţelor lucrului în reţele de calculatoare •
•
•
•
•
2.Caracteristici ale limbajului Java Java este un limbaj de programare de utilizare largă, largă , care are următoarele proprietăţi: este simplu sim plu: deşi sintaxa sint axa se aseamănă aseam ănă cu cea a limbaj elor C/C++, au fost eliminate acele aspecte care constituiau surse de erori sau produceau confuzii ; este orientat pe obiecte : în limbajul Java nu este posibil să se scrie aplicaţii care nu respectă normele programării orientate pe obiecte; este robust : programele scrise sc rise în Java sunt foart e fiabile, deoarece deoare ce sunt prevăzute prevăzut e numeroase verificări atât la compilare, cât şi în timpul e xecutării; este sigur : fiind destinat l ucrului în reţele de calculatoare, la realizarea sistemului Ja va s-a avut în vedere necesitatea ca programele să nu poată aduce daune calculatoarelor pe care rulează, cum ar fi accesul neautorizat la informaţie sau chiar distrugerea acesteia; este port este portabil abil , adică programul poate fi mutat de pe un calculator pe altul, de alt tip hardware şi/sau cu alt sistem de operare; este compilat şi interpretat: programul sursă, scris în limbajul Java, este translatat de către compilatorul Java într-un program intermediar sub formă de cod de octeţi (engleza: bytecode). În timpul execuţiei, acest cod de octeţi este interpretat de către maşina virtuală Java , care conţine un interpretor ; este neutru faţă de arhitectură: arhitectură : codul de octeţi generat de compilatorul Java nu depinde de arhitectura echipamentului pe care acesta va fi executat, deoarece el nu este executat direct de către procesorul hardware al acestui echipament, ci este interpretat de către maşina virtuală Java ; permite programarea progr amarea concurentă concur entă : în limbajul Java se pot scrie scri e programe cu mai multe fire fir e ), care pot fi executate simultan şi sincronizate; de execuţie (engleza: multithreading ), este dinamic , deoarece legarea între el e a claselor şi obiectelor nu se face static (la compilare), ci dinamic (în momentul execuţiei); este distribuit , adică permite realizarea de programe utilizabile în reţele heterogene (care conţin calculatoare de tipuri diferite); •
•
•
•
•
•
•
•
•
•
3. Maşina virtuală Java -este, în general, implementată software sub forma unui produs program prog ram adecvat adec vat calcula cal culatoru torului lui pe care c are acesta aces ta se instale inst alează ază.. •
Ideea de bază a limbajului limbajului şi tehnologiei Java, este ca - pe baza acestora - să se poată creea produse software neutre faţă de arhitectura sistemului de calcul, deci care s ă poată fi executate pe orice echipament, de la produse de uz casnic comandate numeric (televizoare, telefoane, maşini de spălat, frigidere, etc) pană la supercalculatoare. Ea se exprimă prin
1
•
sloganul "Write Once, Run Anywhere" (scrie o singură dată şi rulează oriunde), care arată că un program, după ce a fost scris şi compilat, poate fi executat (rulat) pe oric o ricee calcul ca lculator ator .. Pentru realizarea acestui obiectiv, s-a decis ca în tehnologia Java port Java portabi abilit litatea atea programe prog ramelor lor sa se realizeze la nivel de cod de octeţi ( bytecode), adică sub forma de cod binar bina r destin de stinat at unui calculator abstract, abstract , numit maşina virtuală Java
4. Implementarea maşinii virtuale Java De regulă, arhitectura şi setul de instrucţiuni al calculatorului, pe care se execută un program Java, diferă de cele ale maşinii virtuale Java. În consecinţă, codul de octeţi generat de compilatorul Java nu poate fi executat nemijlocit de procesorul (procesoarele) calculatorului pe care acesta se execută. Dacă este realizată software (aşa cum se întamplă în majoritatea cazurilor), maşina virtuală Java este ea însăşi un produs program, care este scris şi compilat special pentru tipul de calculator pe care se instalează, deci foloseşte s etul de instrucţiuni nativ al acestuia. Acest produs prod us program progr am trebuie să respecte specificaţia maşinii virtuale Java , dar realizarea concretă depinde de tipul de calculator pe care se instalează. Mai mult, pentru acelaşi calculator pot fi realizate mai multe maşini virtuale virtuale Java, care toate respecta specificaţia, dar diferă între ele prin modul de realizare. În principiu, componenta principală a maşinii virtuale Java este un interpretor, adică un program prog ram care parcurge parc urge instrucţ inst rucţiuni iunile le conţinut conţ inutee în codul codu l de octeţi oct eţi Java din memoria memo ria maşinii maşi nii virtuale Java şi le converteşte în instrucţiuni native, care pot fi executate de procesorul calculatorului gazdă. Această conversie necesită un anumit timp, din care cauză durata de execuţie a unui program interpretat este intotdeauna mai mare decât a unuia compilat direct în codul nativ. Din această cauză, principala deficienţă care se semnala la primele implementări ale maşinii virtuale Java era că durata de execuţie a programelor era sensibil mai mare decât a celor scrise in limbaje "tradiţionale" compilate, cum ar fi C, C++, Pascal, Fortran etc. Implementările moderne ale maşinii virtuale Java se caracterizează prin mărirea sensibilă a vitezei de executie, care se apropie deja de cea a programelor compilate. Aceasta se realizează, în special, prin introducerea unei compilări "just in time ": codul de octeţi este compilat, în momentul execuţiei, in cod nativ pentru calculatorul gazdă şi abia apoi este executat. Desigur că cea mai eficientă reducere a duratei de execuţie se produce atunci când maşina virtuală Java este implementata hardware, astfel încât codul de octeti Java (bztecode) este cod nativ al acestei maşini. În acest caz, durata de execuţie a programului este aceeaşi cu cea a unui program prog ram compilat comp ilat tradiţi trad iţional onal..
5. Tipuri de produse software scrise în Java Limbajul Java este folosit cel mai frecvent pentru a scrie urmatoarele trei tipuri de programe:
aplicaţie - este un produs software care se instalează pe un anumit calculator şi funcţionează direct sub controlul sistemului de operare, având acces la toate resursele calculatorului respectiv. Una din clasele aplicaţiei trebuie sa conţină metoda principală , cu care începe execuţia aplicatiei. Această metodă se numeşte main şi are forma: publi publ i c static void main(String args[]) { // corpul metodei }
2
•
sloganul "Write Once, Run Anywhere" (scrie o singură dată şi rulează oriunde), care arată că un program, după ce a fost scris şi compilat, poate fi executat (rulat) pe oric o ricee calcul ca lculator ator .. Pentru realizarea acestui obiectiv, s-a decis ca în tehnologia Java port Java portabi abilit litatea atea programe prog ramelor lor sa se realizeze la nivel de cod de octeţi ( bytecode), adică sub forma de cod binar bina r destin de stinat at unui calculator abstract, abstract , numit maşina virtuală Java
4. Implementarea maşinii virtuale Java De regulă, arhitectura şi setul de instrucţiuni al calculatorului, pe care se execută un program Java, diferă de cele ale maşinii virtuale Java. În consecinţă, codul de octeţi generat de compilatorul Java nu poate fi executat nemijlocit de procesorul (procesoarele) calculatorului pe care acesta se execută. Dacă este realizată software (aşa cum se întamplă în majoritatea cazurilor), maşina virtuală Java este ea însăşi un produs program, care este scris şi compilat special pentru tipul de calculator pe care se instalează, deci foloseşte s etul de instrucţiuni nativ al acestuia. Acest produs prod us program progr am trebuie să respecte specificaţia maşinii virtuale Java , dar realizarea concretă depinde de tipul de calculator pe care se instalează. Mai mult, pentru acelaşi calculator pot fi realizate mai multe maşini virtuale virtuale Java, care toate respecta specificaţia, dar diferă între ele prin modul de realizare. În principiu, componenta principală a maşinii virtuale Java este un interpretor, adică un program prog ram care parcurge parc urge instrucţ inst rucţiuni iunile le conţinut conţ inutee în codul codu l de octeţi oct eţi Java din memoria memo ria maşinii maşi nii virtuale Java şi le converteşte în instrucţiuni native, care pot fi executate de procesorul calculatorului gazdă. Această conversie necesită un anumit timp, din care cauză durata de execuţie a unui program interpretat este intotdeauna mai mare decât a unuia compilat direct în codul nativ. Din această cauză, principala deficienţă care se semnala la primele implementări ale maşinii virtuale Java era că durata de execuţie a programelor era sensibil mai mare decât a celor scrise in limbaje "tradiţionale" compilate, cum ar fi C, C++, Pascal, Fortran etc. Implementările moderne ale maşinii virtuale Java se caracterizează prin mărirea sensibilă a vitezei de executie, care se apropie deja de cea a programelor compilate. Aceasta se realizează, în special, prin introducerea unei compilări "just in time ": codul de octeţi este compilat, în momentul execuţiei, in cod nativ pentru calculatorul gazdă şi abia apoi este executat. Desigur că cea mai eficientă reducere a duratei de execuţie se produce atunci când maşina virtuală Java este implementata hardware, astfel încât codul de octeti Java (bztecode) este cod nativ al acestei maşini. În acest caz, durata de execuţie a programului este aceeaşi cu cea a unui program prog ram compilat comp ilat tradiţi trad iţional onal..
5. Tipuri de produse software scrise în Java Limbajul Java este folosit cel mai frecvent pentru a scrie urmatoarele trei tipuri de programe:
aplicaţie - este un produs software care se instalează pe un anumit calculator şi funcţionează direct sub controlul sistemului de operare, având acces la toate resursele calculatorului respectiv. Una din clasele aplicaţiei trebuie sa conţină metoda principală , cu care începe execuţia aplicatiei. Această metodă se numeşte main şi are forma: publi publ i c static void main(String args[]) { // corpul metodei }
2
applet (miniaplicaţie) - este un program care se transmite sub formă de cod de octeţi (bytecode) prin reţeaua de calculatoare şi este executat în cadrul unui navigator (browser) de Web , fără a avea acces la fişierele sau sistemul de intrare/ieşire al calculatorului pe care se execută; servlet - un program care se execută pe un server dein reţea.
6. Introducere în programarea orientată pe obiecte Programarea orientată pe obiecte (POO) este o formă de programare, în care programatorii definesc clase de obiecte, iar programul conţine un ansamblu de clase şi obiecte, care comunică între ele prin mesaje. Clasa este o extensie a conceptului de tip de date şi conţine o structură de date, îm preună cu metodele (functiile) care se aplica acestor date. Obiectul este o instantiere (o instanta) a clasei. In acelasi program se pot folosi mai multe obiecte apartinand aceleeasi clase, sau unor clase diferite. Fiecare obiect se caracterizeaza prin stare sta re si comportament . Starea obiectului depinde de datele pe care acesta le contine, in timp ce comportamentul este dat de metodele clasei respective. In general, comunicarea prin mesaje consta in invocarea de metode. Daca obiectul a invoca o metoda a obiectului b, aceasta poate avea ca efect modificarea starii obiectului b (adica modificarea unor date continute in structura de date a lui b) si/sau poate primi o valoare intoarsa de metoda respectiva. Se considera ca, prin invocarea metodei, obiectul a a transmis un mesaj obiectului b, ceeace a provocat din partea acestuia un anumit raspuns (deci b a manifestat o anumita comportare). Atat variabilele, cat si metodele pot fi statice sau nestatice. Variabilele statice (ale clasei) apartin clasei, adica au aceeasi valoare pentru toate obiectele clasei respective. Variabilele de instanta (nestatice) apartin obiectului (instantei), deci au valori diferite de la un obiect la altul.
Metodele statice (ale clasei) pot folosi numai variabilele statice ale clasei respective, in timp ce metodele nestatice pot folosi atat variabilele statice, cat si pe cele ale instantei. Din punct de vedere al modului de acces , datele si metodele unei clase pot fi publice sau private priv ate.. Cele Ce le publice sunt accesibile din orice alta clasa, in timp ce cele private sunt accesibile numai din clasa careia ii apartin.
7. Sablon de aplicaţie simplă în limbajul Java În prima parte a acestui curs, în aplicaţiile făcute la curs şi la laborator vom utiliza următorul şablon: class { public publ ic static stat ic void main(St mai n(String ring args[]) args []) { // corpul corp ul metod m etodei ei main
} }
3
Părţile scrise cu negru (inclusiv parantezele şi acoladele) le vom considera obligatorii, iar cele scrise cursiv cu roşu sunt la latitudinea programatorului. - este numele clasei, fiind ales de către programator cu respectarea următoarelor condiţii: - numele clasei trebuie să înceapă cu o literă şi este format numai din litere, cifre şi - eventual - liniuţa de subliniere; - prin convenţie (deşi aceasta nu este o regulă de sintaxă), numele de clasă începe întotdeauna cu o majusculă; - în cazul numelor compuse din mai multe cuvinte, fiecare cuvânt începe cu majusculă; - lungimea numelui nu este limitată, dar nu este recomandabil sa fie prea mare.
// corpul metodei main
- este o succesiune de instrucţiuni şi comentarii care respectă sintaxa
limbajului Java
8. Editarea fisierului sursă Pentru început, vom considera că aplicaţia este constituită dintr-o singură clasă, care respectă şablonul indicat anterior . Programul sursă pentru această clasă va fi editat sub forma unui fişier separat, care are acelaşi nume cu clasa şi are extensia .java. Pentru crearea fişierului se va folosi un editor de text simplu , care generează numai text neformatat, de exemplu "Notepad" daca lucraţi sub Windows sau sub Linux cu WinLinux99, respectiv "Text Editor" sau "Advanced Editor", daca lucraţi sub Linux cu KDE.
9. Compilarea şi eliminarea erorilor semnalate de compilator Translatarea programului sursă în program sub forma de cod de octeţi (bytecode) se face cu ajutorul compilatorului Java, numit javac. Î n acest scop, va deplasaţi în subdirectorul în care se găseşte programul sursă pe care doriţi să-l compilaţi şi daţi comanda javac
După ce aţi dat această comandă, veţi obţine unul din următoarele rezultate:
1. Pe ecran apare din nou promptul sistemului de operare, fără a se afişa un mesaj de
eroare. În acest caz, compilarea a decurs normal, iar dacă daţi comanda dir veţi constata ca în subdirectorul curent a apărut un nou fişier, care poartă numele clasei şi extensia class. Acesta este fişierul care conţine bytecode-ul clasei compilate. 2. Obţineţi un mesaj de eroare, care indică fie că există erori în program, care au fost sesizate de compilator, fie că există erori în linia de comandă prin care aţi cerut compilarea. În ambele cazuri, este necesar să eliminaţi erorile şi să reluaţi compilarea
10. Executarea aplicaţiei Dacă în directorul curent există fişierul solicită prin comanda
.class ,
executarea acestei aplicaţii se
java
Remarcăm că se dă ca parametru numai numele clasei, fără extensia class. Efectul acestei comenzi este, fie executarea aplicatiei, fie aparitia unui mesaj de eroare de execuţie. Prin comanda java se pune în execuţie interpretorul maşinii virtuale Java. Acest interpretor verifică dacă în directorul curent există fişierul .class . Daca acesta există, încarcă în memorie codul de octeţi pe care îl conţine şi pune în execuţie metoda public static void main(). Dacă fişierul nu există, sau dacă el nu conţine o astfel de metodă, se semnalează printr-un
4
mesaj de eroare.
11. ERORI LA COMPILARE SI INTERPRETARE Exemplul 1 de eroare
Considerăm că, după ce aţi creat fişierul sursă PrimaAplicatie.java, daţi comanda jamac PrimaAplicatie.java
în care numele compilatorului este introdus greşit (jamac în loc de javac). Ca efect, veţi obtine un mesaj prin care se arată că cuvantul jamac nu este o comandă corectă (nu este numele unei comenzi interne a sistemului de operare sau numele unui program executabil), de exemplu: jamac: command not found Exemplul 2 de eroare
Să considerăm acum că numele fişierului sursă este introdus greşit, de exemplu: javac PimaAplicatie.java
În acest caz, mesajul de eroare este can't read: PimaAplicatie.java
adică "nu pot citi: PimaAplicatie.java", ceeace înseamnă că un astfel de fişier nu există în directorul curent. Exemplul 3 de eroare
Să urmărim ce se întâmplă dacă introducem comanda javac PrimaAplicatie
în care numele fişierului este corect, dar lipşeste extensia. În acest caz, obtineţi următorul mesaj: PrimaAplicatie is an invalid o ption or argument. usage: javac
urmat de o lista de opţiuni. Aceasta înseamnă că nu s-a respectat sintaxa comenzii, care cere ca comanda javac să fie urmată (eventual) de una sau mai multe opţiuni din lista dată, după care trebuie să apară numele fişierului (fişierelor) sursă care trebuie compilate. Aceste nume de fişiere trebuie sa conţină obligatoriu extensia java
12. Şiruri Şirul se reprezintă în program printr-o succesiune de caractere cuprinsă între ghilimele. Iată câteva exemple de şiruri: "sir de caractere" "ABCDefgh" "1A23bc7" "*+_/?" "" Ultimul exemplu este un şir vid (care nu conţine nici un caracter).
13.Operatii asupra sirurilor de caractere Concatenarea şirurilor Asupra şirurilor se poate aplica operaţia de concatenare, reprezentata prin operatorul +. Expresia şir1+ şir2, în care operatorul + este plasat între două şiruri, are ca rezultat un nou şir, care conţine cele două şiruri-operanzi puse unul după altul. De exemplu, expresia
5
"abcde"+"fgh" dă ca rezultat şirul "abcdefgh". Operaţia de concatenare este asociativă, dar nu este comutativă. De exemplu, expresiile următoare sunt echivalente, ca urmare a asociativităţii: "ABC"+"DEF"+"GH" ("ABC"+"DEF")+"GH" "ABC"+("DEF"+"GH") "ABCDEFGH" În schimb, expresia "uvw"+"ab" este echivalentă cu "uvwab", în timp ce expresia "ab"+"uvw" este echivalentă cu "abuvw", deci concatenarea nu este comutativă
14.Metode pentru afişarea pe ecran a şirurilor În capitolul precedent, am folosit deja pentru afişarea şirurilor de caractere metoda System.out.println(<şir>) la care vom adăuga acum şi metoda System.out.print(<şir>) În ambele metode, argumentul <şir> este un şir de caractere, care s e afişeaza pe ecran. Deosebirea dintre ele constă în faptul că, după afişarea şi rului, metoda println transmite şi comanda de trecere la linie nouă, în timp ce metoda print nu transmite o astfel de comandă. În consecinţă, în cazul afişării cu println, următoarea afişare se va face de la început de linie nouă, iar la afişarea cu print afişarea următoare se va face în continuare, pe aceeaşi linie. Numele metodei println provine de la print line , care se traduce prin "tipăreşte o linie". Metodele println si print aparţin obiectului out din clasa System. În limbajul Java, clasa System conţine metodele prin care se comunică cu sistemul de operare al calculatorului, iar obiectul out al acestei clase reprezintă dispozitivul de ieşire standard al sistemului , care este de obicei unitatea de afişare de la consolă (ecranul). Metoda println actionează la fel ca metoda print, cu deosebirea că adaugă la sfârşitul şirului afişat caracterul de control \n care constituie comanda de trecere la linie nouă ( New Line ).
15. Unităţile lexicale ale limbajului Java Unităţile lexicale, numite şi lexeme (engl. token, lexeme ) sunt construcţiile elementare ale limbajului ("atomii" acestuia). Acestea sunt simboluri, formate din unul sau mai multe caractere, care au o anumită semnificaţie în limbaj. După rolul îndeplinit, unităţile lexicale sunt: identificatori, cuvinte cheie, cuvinte rezervate, literali, separatori,operatori, comentarii ş i spaţii.
16.Identificatori Numele date programelor sau componentelor acestora (clase, variabile, metode etc.) se numesc identificatori . Identificatorii se aleg de către programator, respectând anumite reguli. În limbajul Java, identificatorii sunt şiruri formate din litere, cifre şi caractere de subliniere ('_'), care încep cu o literă. Lungimea identificatorului nu prezintă importanţă, însă acesta nu poate conţine spaţii libere sau alte caractere, decât cele menţionate aici.
6
17. Cuvinte cheie În orice limbaj de programare, există un set de cuvinte, numite cuvinte cheie, care sunt considerate simboluri sintactice şi nu pot fi folosite în program ca identificatori. În limbajul Java, există următoarele cuvinte cheie: abstract double int strictfp boolean else interface super break extends long switch byte final native synchronized case finally new this catch float package throw privat e char for throws class goto protected transient const if public try continue implements return void default import short volatile do instanceof static while Dintre acestea, const şi goto nu sunt folosite în prezent, dar ele au fost introduse în tabela cuvintelor cheie în vederea unei eventuale utilizări viitoare. Observăm acum că toate exemplele de cuvinte cheie date la începutul acestei secţiuni ( class, public, static, void) sunt prezente în tabela de mai sus.
18. Cuvinte rezervate Se consideră cuvinte rezervate acele cuvinte, care nu pot fi folosite ca identificatori, având semnificaţii speciale. Cuvintele cheie sunt şi ele considerate în majoritatea limbajelor, inclusiv Java, drept cuvinte rezervate. În afară de acestea, în limbajul Java există urmatoarele cuvinte rezervate: true, false, null. Primele două sunt valorile logice adevărat ş i fals , iar al treilea are semnificaţia de referinţă nulă. De fapt, aceste cuvinte rezervate sunt forme speciale de literali. 19. Literali Literalii sunt reprezentările în fişierele sursă ale valorilor constante . Exemple de literali: - caractere: 'a', 'A', '+', '$', '5' ; - şiruri de caractere: "sir de caractere", "abc$79.28#^z"; - numere întregi: 14726, -25413; - numere reale: 12.7389, -0.05673, 2.3075E12, -1.4237E-5 ; - valori logice: true, false; - referinţa nulă: null. 20. Separatori Separatorul este un caracter care delimitează formele sintactice sau le separă între ele. În limbajul Java se folosesc următorii separatori : { } ( ) [ ] ; , .
Spaţiul liber şi operatorii indeplinesc, de asemenea, rolul de separatori. Aproape toţi aceşti separatori au fost deja folosiţi în exemplele date în acest capitol.
7
21. Operatori Operatorii sunt simboluri ale unor o peraţii pera ţii . Am folosit deja simbolul + ca operator de concatenare (deci simbol al operaţiei de concatenare). Operatorul poate fi format din unul sau mai multe caractere. Entitatea asupra căreia se aplică aplică operatorul se numeşte operand. După numărul de operanzi, operatorii pot fi unari , binari sau ternari. Din punct de vedere matematic, operatorii sunt funcţii cu unul, două sau trei argumente (argumentele fiind operanzii). De exemplu, expresia a+b , în care + este un operator binar, iar a ş i func ţie de argumente a si b, care are ca valoare suma valorilor celor două b sunt operanzi, este o funcţie argumente.
efec t lateral lateral , care lasa După efectul operatorului asupra operanzilor, operatorii pot fi fără efect valorile operanzilor nemodificate, şi cu efect lateral , care modifică valorile operanzilor. Astfel, operatorul + din exemplul anterior, este un operator fără efect lateral. În schimb, în expresia ++a operatorul de incrementare ++ are efect lateral deoarece, în urma efectuarii operaţiei, valoarea operandului a creşte cu o unitate. 22. Comentarii in fisierul sursa După cum s-a aratat deja, în fişierele sursă pot fi introduse comentarii comentarii,, care au rolul de a da omului, care citeşte programul respectiv, anumite explicaţii necesare pentru o mai buna înţelegere a acestuia. Din punct de vedere sintactic, întregul comentariu este privit ca o singură unitate lexicală, care este ignorată de către compilator, deci nu are efect asupra codului de octeţi generat de acesta.
23. Spaţii Între unităţile lexicale ale programului pot fi introduse oricât de multe spaţii spaţ ii libe l ibere re , fără ca acestea să aibă influenţă asupra sintaxei sau semanticii programului. programului. Mai multe spaţii libere succesive sunt tratate de compilator ca şi când ar fi un singur spaţiu. 24. Variabile In matematică, variabila este un simbol sim bol dat unei valori, care aparţine unei mulţimi de valori ce constituie domeniul de definiţie al variabilei respective. În programare, variabila este un nume căruia i se asociază o valoare. Numele variabilei este un identificator , iar valoarea variabilei trebuie să aparţină unui anumit tip de date . Asupra valorilor variabilelor pot fi efectuate prin program anumite operaţii.
25. Declararea şi iniţializarea variabilelor În limbajul Java, orice variabilă trebuie declarată înainte de a fi utilizată utiliza tă . Prin declararea variabilei se înţelege precizarea, pentru compilator, a tipului ş i numelui acesteia. Iniţiali Iniţ iali zarea zar ea acesteia i se dă pentru prima dată dată o valoare şi deci i se alocă variabilei se face atunci, când acesteia spaţiu în memorie. Dacă, la declararea variabilei, aceasta nu este şi iniţializată în mod explicit, atunci ea este iniţializata cu o valoare implicită , care va fi specificată la descrierea fiecărui tip
26. Variabile finale În limbajul Java, se numesc variabile finale acele "variabile", ale căror valori nu pot fi modificate prin program. Acestea sunt deci, de fapt, nişte constante cu nume . Ele se aseamănă cu
8
variabilele propriu-zise prin faptul că sunt tot perechi nume - valoare, numai că valoarea lor se dă o singură dată, sub forma de iniţializare în declaraţia de tip sau sub forma de atribuire, după care nu mai poate fi modificată. Se obişnuieşte ca numele de variabile finale să fie scrise în întregime cu majuscule. Declaraţia de tip este la fel cu cea pentru variabile obişnuite, dar are in faţă modificatorul final, care este un cuvânt cheie
27. Tipul de date -este unul din conceptele fundamentale ale programării calculatoarelor. Tipul de date este o mulţime de valori, asociată cu o mulţime de operaţii care se pot face asupra valorilor respective. În limbajul Java, tipurile de date se împart în două categorii: tipuri primiti prim itive ve şi tipuri referinţă. În limbajul Java, tipurile de date se împart în două categorii: tipuri primiti prim itive ve şi tipuri referinţă.
28. Tipurile de date primitive sunt predefinite în limbaj. Aceasta înseamnă că numele, mulţimea de valori, mulţimea de operaţii şi tipul tipul rezultatului operaţiilor pentu fiecare tip primiti prim itivv sunt su nt impus i mpusee prin pr in limb l imbaj aj şi, deci, deci , nu trebuie tre buie definit defi nitee şi nu pot p ot fi modif m odifica icate te de programa prog ramator. tor. Tipurile de date primitive în limbajul Java se clasifică astfel: • •
tipul boolean; tipurile numerice o tipuri intregi: byte, short, int, long; o tipuri reale: float si double; o tipul char
Pentru fiecare tip de date vom arăta reprezentarea externă, externă, reprezentarea internă, internă, operaţiile şi operatorii corespunzători. Prin reprezentare externă , înţelegem regulile după care se scriu valorile datelor respective în programe prog rame,, în î n documen doc umente te sau pe ecran e cranul ul calculat calc ulatorul orului. ui. Repreze Repr ezentar ntarea ea exter e xternă nă a valori va loriii întrî ntr-un un program prog ram se numeş n umeşte te literal . Prin reprezentare internă , înţelegem forma sub care datele respective apar în memoria maşinii virtuale Java. O proprietate foarte importantă a reprezentării interne a datelor este că aceasta, fiind destinată maşinii virtuale Java, nu depinde de calculatorul concret pe care se va executa program prog ramul. ul.
29. Operaţia de atribuire Prin operaţia de atribuire se dă (se atribuie) unei variabile o nouă valoare, care o înlocuieşte pe cea deja existentă. Operatorul de atribuire este = (semnul egal, care însă aici se citeşte " se atribuie") este un operator binar cu efect lateral . Expresia a=b , în care a este o variabila, iar b este un operand care poate fi un literal, o variabilă sau o expresie , are semnificaţia " se atribuie atri buie variabilei a valoarea operandului b". Atribuirea este posibilă numai daca valoarea operandului sa u dacă da că se s e poate po ate convert conv ertii impli i mplicit cit la aces a cestt ti p. Atribuirea b este de acelasi tip cu variabila a , sau este o operaţie cu efect lateral , deoarece produce modificarea valorii operandului situat în partea stânga a operatorului de atribuire.
9
30. Operaţiile aritmetice Operaţiile aritmetice sunt cele care se a plică unor operanzi numerici, având ca rezultate tot numere. După numărul de operanzi, ele pot fi unare sau binare. Unele operaţii aritmetice unare au şi efect lateral. Tipul rezultatului operaţiilor aritmetice depinde de tipul operanzilor şi va fi discutat la fiecare din tipurile numerice în parte.
31. Operaţii de atribuire compusă Urmând tradiţia limbajului C, în limbajul Java există şi operatori de atribuire compusă, în care operaţia de atribuire este combinată cu una din operaţiile aritmetice. Operatorii de atribuire compusă sunt următorii: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>= . Se observă că fiecare din aceşti operatori are forma op= în care op este un operator aritmetic binar. bina r. Expr E xpresia esia variabila op= operand în care op este un operator aritmetic binar, este echivalentă cu expresia variabila = variabila op operand
şi se evaluează astfel: - se calculează mai întâi valoarea expresiei (variabila op operand)î n care variabila intră cu valoarea sa anterioară; - valoarea astfel calculată se atribuie ca noua valoare a variabilei din partea stânga. Aceasta nouaă valoare este, totodată, şi valoare a expresiei.
32. Operatori binari Operatorii binari nu au efect lateral - deci nu modifică valorile operanzilor operanzilor - şi sunt daţi în tabela de mai jos.
Opera perato torr Expr Expres esie ie + a+ b a-b * a *b / a/ b % a%b
Operaatie Oper tie a du na re s c a de re in m ul t i r e im p a rt i r e mo dul o
Valo aloare area exp exprresie esieii s um a va l or i l o r o per an z i l or di f e r ent a v a l ori l or op er a nz i l or produsul va valoril or op operanz ilor cat ul (r (rezultatul im impartirii) pr primului op operand la la al al do doilea r es t ul i mp a rt i r ii i nt r e gi a p ri m ul u i o per a nd l a a l doi l e a
Prin împărţire întreagă înţelegem împărţirea făcută astfel, încât câtul sa fie un număr întreg (fără extragerea părţii fracţionare (situate dupa virgulă).
33. Operaţii de deplasare binară Urmând "tradiţia" limbajului C, limbajul Java conţine şi operatori de deplasare binară. Aceştia sunt operatori binari (cu doi operanzi) fără efect lateral. Tipul rezultatului operaţiei se stabileşte la fel ca în cazul operaţiilor aritmetice cu numere întregi. Valoarea rezultată se stabileşte astfel: se ia reprezentarea internă a primului operand şi se deplasează la stânga sau la dreapta cu un numar de poziţii binare egal cu cel de al doilea operand.
10
Operatorii de deplasare şi efectele lor sunt prezentate în ta bela de mai jos, în care a şi s sunt operanzi care aparţin unor tipuri întregi.
Operator Expresie Efect << a<> a>>s deplasare la dreapta cu s poziţii binare, cu conservarea semnului >>> a>>>s deplasare la dreapta fără semn , cu s poziţii binare Deplasarea la stânga cu s poziţii este echivalenta cu înmulţirea numărului cu 2 s. Dacă s este suficient de mare, poate avea loc o depăşire binară, la fel ca în cazul înmulţirii aritmetice (cu operatorul *). Deplasarea la dreapta cu s poziţii cu operatorul >> este echivalenta cu împărţirea întreagă la 2 s. Deplasarea biţilor la dreapta cu s pozitii cu operatorul >>> are asupra numerelor pozitive acelaşi efect ca cel al operatorului >> . În schimb, în cazul operanzilor negativi, în cazul operatorului >>> nu se mai conservă semnul, iar modulul numărului se modifică. Aceasta se întâmplă, întrucât pe poziţiile eliberate din partea stângă se înserează bitul 0.
34. Operatia de comparare Comparaţiile sunt operaţii binare fără efect lateral, în care se compară două numere, obţinânduse ca rezultat o valoare de tip boolean. Operatorii prin care se efectuează comparaţia a două numere se numesc operatori relaţionali şi sunt daţi în tabela de mai jos. Operator < <= > >= == !=
Semnificatie mai mic decât mai mic decât sau egal cu mai mare decât mai mare decât sau egal cu este egal cu este diferit de
35. Operaţii logice pe biţi Tot urmând "tradiţia" limbajelor C/C++, în limbajul Java se pot utiliza pentru tipurile de date întregi şi operatorii logici pe biţi ~, &, | si ^. Aceştia sunt operatori fără efect lateral. Operaţiile logice se fac la nivel de bit, adică între fiecare bit al operandului din stânga şi bitul corespunzător al operandului din dreapta, considerându-se ca 0 este echivalent cu false, iar 1 este echivalent cu true. Operatorul unar ~ exprimă negaţia logică, deci înlocuirea lui 0 cu 1 şi invers. Operatorii binari &, | si ^ acţionează la fel ca în cazul tipului boolean, numai că se aplică la nivel de bit. Acţiunea operatorilor este dată în tabela de mai jos, în care a şi b sunt cei doi operanzi, iar ai si bisunt biţii de pe pozitia i a acestor operanzi. În tabelă se dă efectul fiecărei operaţii asupra
11
bitului i al rezultatului.
ai 0 0 1 1
bi 0 1 0 1
~a 1 1 0 0
a&b 0 0 0 1
a|b 0 1 1 1
a^b 0 1 1 0
36. Conversia de tip Dacă este necesar, datele pot fi convertite dintr-un tip în altul. După caz, conversia se poate face implicit, sau poate fi cerută explicit prin program. 37. Conversia de tip implicită se face atunci când prin conversie nu se pierde informaţie. De exemplu, dacă în expresia a=b variabila a este de tip int, iar b este de tip short sau byte, valoarea variabilei b va fi automat convertită la tipul int înainte de atribuire. În tabela de mai jos sunt indicate cu X toate conversiile de tip c are se pot realiza inplicit. În coloana din stânga este tipul datei care este supusa conversiei, iar în capul tabelei (pe prima linie) tipul către care se face conversia. byte byte short char int long float
short X
int X X X
long X X X X
float X X X X X
double X X X X X X
De exemplu, tipul int se poate converti implicit în oricare din tipurile long, float sau double, dar nu şi în tipurile byte sau short.
38. Conversia de tip explicită se face prin operatorul unar numit cast , care are forma ( tip ), adică este format din numele tipului către care se face conversia, cuprins între paranteze. Acesta este un operator fără efect lateral , deci care nu modifică valoarea operandului. De exemplu, expresia (byte)a se va folosi pentru a converti valoarea operandului a la tipul byte. Aceasta înseamnă că valoarea variabilei a rămâne neschimbată, însă valoarea expresiei (byte)a se obţine din cea a lui a prin convertirea ei la tipul byte. Utilizarea operatorului cast se justifică atunci când, în situaţia respectivă, conversia implicită nu este posibilă. Nu este însă greşit dacă folosim acest operator chiar şi când conversia respectivă se poate face şi implicit.
39. Tipuri numerice Sub aspect conceptual, datele care aparţin acestor tipuri sunt numere , asupra cărora pot fi aplicate operaţiile aritmetice (adunare, scădere, înmulţire, împărţire) şi operaţiile de comparaţie aritmetică (mai mic, mai mare, egal, diferit de).
12
Din punct de vedere matematic, aceste date pot fi numere întregi sau reale. Existenţa mai multor tipuri în cadrul fiecăreia din aceste două categorii se datoreşte particularităţilor de reprezentare a datelor în memorie.
Tipurile de date numerice în Java sunt următoarele: • • •
tipuri întregi: byte, short, int, long; tipuri reale (în virgulă mobilă): float şi double; tipul char
40. Tipuri de date întregi Tipurile de date întregi sunt byte, short, int, long ş i char . Conceptual, datele care aparţin tipurilor byte, short, int şi long sunt numere întregi , în timp ce tipul char conţine caractere (litere, cifre, semne de punctuaţie etc). Întrucât caracterele se codifică în memoria calculatorului prin numere întregi fără semn, în limbajul Java asupra lor se pot aplica toate operaţiile pentru numere întregi. Totusi, datorită particularităţilor pe care le prezintă, noi vom trata tipul char separat.
41. Tipul Boolean Mulţimea de valori a acestui tip este {true, false} . Ea conţine cele două valori admise de logica booleană: true înseamnă adevărat , iar false înseamnă fals . Asupra datelor din acest tip pot fi aplicate operaţiile de atribuire, de comparaţie (== si != ) şi operaţiile algebrei booleene (operaţiile logice).
Operatorii booleeni Operatorul de negaţie este un operator unar fără efect lateral şi se reprezintă prin simbolul ! (semnul exclamării). Expresia !a, în care a este un operand boolean, se citeşte non -a şi se interpretează ca negaţia lui a: daca a are valoarea true, atunci !a are valoarea false ş i invers. Operatorii logici binari sunt operatori fără efect lateral, prin care se realizează operaţiile logice ŞI, SAU şi SAU-EXCLUSIV. - Operatorii & si && realizeaza operatia logica ŞI. Expresiile a&b şi a&&b ,în care a ş i b sunt operanzi de tip boolean, are valoarea true (adevărat) dacă şi numai dacă atât a cât şi b au valoarea true. În celelalte cazuri expresia are valoarea false. - Operatorii | si || realizează operaţia logică SAU. Expresiile a|b şi a||b , în care a ş i b sunt operanzi de tip boolean, are valoarea false dacă şi numai dacă ambii operanzi au valoarea false. În celelalte cazuri expresia are valoarea true. - Operatorul ^ realizează operatia logică SAU-EXCLUSIV. Expresia a^b , în care a ş i b sunt operanzi de tip boolean, are valoarea true dacă şi numai dacă cei doi operanzi au valori diferite (unul este adevărat, iar celălalt fals). Dacă cei doi operanzi au valori identice, valoarea expresiei este false. 42. Operaţii şi operatori pentru date de tip întreg Asupra datelor de tip întreg se pot aplica operaţii de atribuire, de conversie de tip, operaţii aritmetice, de comparaţie, operaţii de deplasare binară, operaţii logice pe biţi şi operaţii de atribuire compusă. Primele trei au fost discutate anterior şi vom indica aici numai unele particularităţi ale aplicării lor în cazul datelor de tipuri întregi.
13
Conversia de tip şi atribuirea Diferitele tipuri de date întregi diferă între ele prin lungimea reprezentării lor interne. La convertirea unui tip mai scurt în unul mai lung (de exemplu a unui byte sau short în int) valoarea numărului rămâne neschimbată. Din această cauză, această conversie se poate face implicit. În schimb, la conversia de la o lungime mai mare la una mai mică, se reţin numai octeţii situaţi în partea dreaptă a numărului, eliminându-se octeţii din stânga care depăşesc noua lungime. Prin aceasta este posibil să se modifice valoarea numărului şi chiar semnul lui. Din această cauză, la efectuarea unor astfel de conversii, programatorul trebuie să-şi asume raăspunderea folosind operatorul cast .
43. Tipuri de date în virgulă mobilă Mulţimile de valori pentru tipurile de date în virgulă mobilă Conceptual, datele care aparţin acestor tipuri sunt numere reale. În limbajul Java există două tipuri de date reale (numite şi tipuri de date flotante sau în virgulă mobilă): Tipul Lungimea float 4 octeti (32 biti) double 8 octeti (64 biti)
Intervalul de valori [-3.402347e+38f, ... 3.402347e38f] [-1.7976931348623157e+308, ... 1.7976931348623157e308]
Reprezentarea externă a numerelor în virgulă mobilă se poate face în următoarele moduri: a/ ca numere reale fără exponent, în care partea întreagă este separată de cea fracţionara prin punct; b/ ca numere reale cu exponent, în care un număr întreg sau unul real fără exponent, numit mantisa sau coeficient , este urmat de un exponent zecimal , format din litera e sau E urmata de un numar intreg. Semnificaţia este că mantisa se înmulteşte cu 10 ridicat la o putere egală cu exponentul. O caracteristică importantă a numerelor în virgulă mobilă este precizia. Se numeşte precizie numărul maxim de cifre semnificative pe care îl poate avea mantisa pentru tipul de date respectiv. Aceasta depinde de numărul de biţi alocaţi mantisei în reprezentarea internă. În cazul limbajului Java, datele de tip float pot avea cel mult 7 cifre semnificative, iar cele de tip double cel mult 16 cifre semnificative. În reprezentarea externă a numărului se pot folosi şi mai multe cifre, dar cele care depăşesc lungimea admisă nu vor fi luate în consideraţie la conversia din forma externă în cea internă.
44. Tipul char Tipul de date char Datele de tip char sunt caractere, adică simboluri tipografice elementare: litere, cifre, semne de punctuaţie, simboluri matematice, etc. În limbajul Java, reprezentarea internã a caracterelor se face pe 2 octeţi (16 biţi), în sistemul Unicode. In acest sistem, caracterele sunt codificate în memoria internă prin numere întregi pozitive în intervalul [0, 65535]. În fluxurile de date de intrare/ieşire şi în fişiere, caracterele pot fi reprezentate şi în alte coduri. Codul cel mai frecvent folosit în aceste scopuri este ASCII, în care reprezentarea caracterelor se face pe un singur octet, deci prin numere întregi fără semn în intervalul [0, 255]. Remarcăm ca datele de tip char sunt singurul tip de date întregi fără semn din limbajul Java , mulţimea de valori a acestui tip de date fiind intervalul de numere naturale [0, 65535].
14
Reprezentarea externă a caracterelor se face în una din următoarele forme: a/ punând caracterul respectiv între apostrofuri: 'a', 'B', '+', '(', '3', etc; b/ folosind o secvenţă escape, în care apare codul numeric hexazecimal al caracterului respectiv, în Unicode, de ex: '\u006c' sau '\uffff'; într-o astfel de secvenţă, codul numeric al caracterului (format din patru cifre hexazecimale) este precedat de \u; c/ folosind o secventa escape pentru caracterele speciale din urmatorul tabel: Caracterul Reprezentarea in Unicode Semnificatia '\b' '\u0008' deplasare la stânga cu o poziţie ( backspace) '\t' '\u0009' tabulare orizontală (horizontal tab) '\n' '\u000a' trecere la linie nouă ( line feed , NL) '\f' '\u000c' salt la pagina nouă ( form feed ) '\r' '\u000d' întoarcerea carului ( carriage return, CR) '\"' '\u0022' ghilimele (double quote ) '\'' '\u0027' apostrof ( single quote) '\\' '\u005c' bară inversă (backslash) Datele de tip char pot fi folosite în operaţii numerice, în care caz ele sunt interpretate drept numere intregi fără semn, conform cu reprezentarea lor internă prin numere binare. Din acest motiv, în limbajul Java datele de tip char sunt incluse în categoria celor de tipuri întregi.
45. Expresii cu date primitive În programare, expresia este o combinaţie permisă ("legală", corectă) de simboluri, care reprezintă o valoare. Tipul expresiei este acelaşi cu tipul valorii ei. Putem avea, deci, expresii de tip boolean, int, long, float, double etc. Fiecare limbaj de programare are regulile sale, prin care se stabileşte ce expresii sunt permise sau nepermise. În limbajul Java, expresia poate conţine literali, variabile, operatori, operanzi, funcţii şi paranteze şi trebuie să poată fi evaluată (calculată), astfel încât să se obţină o valoare.
46. Precedenţa operatorilor La evaluarea unei expresii, prezinta o importanţă deosebită ordinea în care se aplică operatorii pe care îi conţine, deoarece de această ordine poate să depindă valoarea expresiei. În toate limbajele de programare, în care se folosesc expresii, se stabilesc şi anumite reguli de precedenţă şi de asociativitate, pe baza cărora se stabileşte ordinea de evaluare. Fiecărui operator i se asociază o precedenţă, adică un nivel de prioritate în aplicarea operatorului respectiv. De exemplu, în expresia a+b*c operatorul * se va aplica înaintea operatorului +, deoarece are precedenţa superioară. În consecinţă, aceasta expresie se va calcula ca şi când ar fi s crisă sub forma a+(b*c). În limbajul Java, la stabilirea ordinii operaţiilor se aplica următoarele reguli: - operatorii unari se aplică înaintea celor binari; - expresiile din interiorul parantezelor se evaluează înaintea celor din exterior; - dacă, într-o expresie, toţi operatorii au acelaşi nivel de precedenţă, ei se aplică de la stânga la
15
dreapta; - operanzii unui operator se evalueaza înainte de a se aplica operatorul respectiv (deci operatorul se aplică întotdeauna asupra valorilor operanzilor săi); dacă operaţia este binară, operandul din partea stângă se evaluează înaintea celui din partea dreaptă ; - nivelul de precedenţă al operatorilor se stabileşte conform cu tabela de mai jos, în care: • •
toţi operatorii din aceeaşi celulă a tabelei au acelaşi nivel de precedenţă; operatorii de pe un nivel superior se aplică înaintea celor de pe nivelurile inferioare.
47. Expresia condiţională Urmând "tradiţia" limbajului C, în limbajul Java există operatorul ternar (cu trei operanzi) ?: numit operatorul condiţional , care este utilizat în cadrul următoarei expresii condiţionale : operand1 ? operand2 : operand3
unde: operand1 - expresie booleană; operand2 ş i operand3 - expresii de tipuri compatibile : fie ambii operanzi de tip boolean, fie ambii
de tipuri numerice, fie ambii de tipuri referinţă. Evaluarea expresiei decurge astfel: - se evaluează operand1 obţinându-se o valoare booleană; - dacă operand1 are valoarea true, atunci valoarea expresiei condiţionale este cea care se obţine evaluând operand2; altfel, este cea care se obţine evaluând operand3.
48. Instrucţiuni În limbajul Java, procesul de calcul este controlat de instrucţiuni (enunţuri). Fiecare instrucţiune indică una sau mai multe acţiuni pe care trebuie să le execute calculatorul. Corpul oricărei metode este constituit dintr-o succesiune de instrucţiuni. Executarea metodei constă î n executarea acestor instrucţiuni într-o ordine determinată. Instrucţiunile pot fi grupate în blocuri .
După structura lor, instrucţiunile pot fi simple sau structurate. Instrucţiunile simple nu conţin în interiorul lor alte instrucţiuni. Există trei categorii principale de instrucţiuni (enunţuri) simple: declaraţiile de variabile locale, instrucţiunile-expresie şi instrucţiunea vidă. La scrierea lor se respectă următoarele reguli: •
•
•
toate instrucţiunile simple se termină cu caracterul ';' (punct şi virgulă) . Instrucţiunea vidă este formată numai din acest caracter; declaraţiile de variabile locale servesc pentru a specifica tipul, numele şi (opţional) valoarea iniţială a variabilelor. Forma sintactică şi utilizarea declaraţiilor au fost prezentate anterior; instrucţiunile-expresie sunt formate dintr-o expresie de atribuire, de incrementare/decrementare sau de invocare de metodă, urmată de caracterul ';'.
49. Principiile programării structurate
16
Programarea structurată este o orientare în conceperea şi alcătuirea programelor, având ca obiectiv o mai bună gestionare a complexităţii acestora, ţinând cont de particularităţile gândirii umane. Conform metodei programării structurate, la conceperea unui program, este recomandabil să se respecte următoarele principii: 1. Teorema de structură: orice program poate fi întocmit folosind numai trei structuri de control fundamentale: structura secvenţială, structura alternativă şi structura repetitivă. 2. La conceperea programelor se recomandă să se aplice tehnica de elaborare descendentă (în engleză Top-Down), numită şi tehnica rafinărilor succesive. 3. Domeniile de valabilitate (de vizibilitate) ale variabilelor şi structurilor de date trebuie să fie limitate.
50. Structura secvenţială În mod "natural", se consideră că instrucţiunile se execută în ordinea în care acestea figurează în program. Înlănţuirea instrucţiunilor (transmiterea "controlului" de la o instrucţiune la alta) se face, în acest caz, conform schemei logice din figura 1. În pseudocod, aceeaşi secvenţă de program se scrie astfel: ....
Există, deci, un număr oarecare (n) de instrucţiuni, care se execută una dupa alta, în ordinea în care sunt scrise în program.
51. Structura alternativă (condiţională, de decizie) Un fragment de program are structura alternativă (numită şi structură condiţională sau de decizie), atunci când se alege una din două căi posibile, în funcţie de modul în care este satisfăcută sau nu o anumită condiţie. Se observă că există o asemănare între instrucţiunea alternativă şi expresia condiţională. În ambele cazuri se verifică dacă este satisfacută o condiţie şi - în funcţie de rezultatul obtinut - se alege una din două variante posibile. Deosebirea este următoarea: - în cazul expresiei condiţionale se alege una din cele două expresii conţinute în aceasta, iar rezultatul obţinut este valoarea expresiei astfel alese; - în cazul structurii de control alternative se alege una din cele doua instrucţiuni conţinute în această structură; instrucţiunea astfel aleasă este executată, iar rezultatul obţinut este efectul (lateral) produs de executarea acestei instrucţiuni.
52. Instrucţiunea if Instrucţiunea if serveşte pentru realizarea structurii alternative din programarea structurată. Sub forma ei cea mai simplă, această instrucţiune se scrie astfel: if(expresie_booleană ) instrucţiune
unde instrucţiune poate fi orice instrucţiune valabilă în limbajul Java: instrucţiune simplă sau structurată, inclusiv un bloc sau un alt if. Remarcăm că în forma generală de mai sus nu am pus la sfârşit caracterul ';' (punct şi virgulă). Dacă instrucţiune este o instrucţiune simplă, ea include şi acest simbol.
17
Semnificaţia instrucţiunii if este următoarea: dacă valoarea expresiei booleene din paranteză este true, atunci se execută instrucţiune, iar altfel nu se execută nimic, continuându-se programul. 53. Instrucţiunea if .. else Instrucţiunea if .. else realizează ambele ramuri ale structurii alternative şi are forma if(expresie_booleană) instrucţiune_1
else instrucţiune_2
în care instrucţiune_1 şi instrucţiune_2 pot fi instrucţiuni simple sau structurate. Interpretarea acestui if..else este următoarea: dacă expresie_logică are valoarea true, atunci se execută instrucţiune_1, iar altfel se execută instrucţiune_2.
54. Structura repetitivă (ciclu, buclă) În cazul structurii de control repetitive, o instrucţiune sau o secvenţă de instrucţiuni se repetă cât timp este satisfacută o anumită condiţie. Structura repetitivă fundamentală, acceptată în teoria programării structurate, este cea de ciclu cu test iniţial . Schema logică a acestei structuri de control este dată în figura 3. Executarea acestei structuri are loc astfel: 1. se evaluează expresia booleană care reprezintă Condiţia; 2. dacă valoarea acestei expresii este true, deci condiţia este satisfacută, se merge pe ramura DA şi se executaă instrucţiunea din corpul ciclului, după care se trece la punctul 1; 3. altfel (deci dacă condiţia nu este satisfacută) se merge pe ramura NU şi se iese din ciclu. Se observă, deci, că se va executa instrucţiunea în mod repetat, cât timp este satisfăcută condiţia. În pseudocod, această structură de control se programează astfel: cât_timp execută
sfârşit_ciclu În unele versiuni de pseudocod, în loc de o singură se poate pune o secvenţă de instrucţiuni. Deşi, din punct de vedere al teoriei programării structurate, ciclul cu test iniţial este suficient ca structură repetitivă, în multe limbaje de programare (inclusiv Java), din motive de comoditate a programării se admite şi o a doua formă de astfel de structură, numită ciclu cu test final . Schema logică a acestui ciclu este dată în figura 4.
55. Instrucţiunea switch Deşi în teoria programării structurate se demonstrează că, pentru a realiza programe cu structură ramificată, este suficient să se folosească structura de control alternativă, realizată în limbajul Java prin instrucţiunea if..else, în practica programării se admit şi structuri de comutare sau de selecţie,
18
care sunt prezente in diferite limbaje de programare. Aceste structuri permit să se aleagă una din mai multe ramuri paralele,alegerea depinzând de valoarea unei expresii numită comutator sau selector. În acelaşi timp, ele respectă principiul de bază al programării structurate, conform căruia fiecare structură de control trebuie să aibă un singur punct de intrare şi un singur punct de ieşire, ast fel că se încadrează în această metodă de elaborare a programelor. În limbajul Java, structura de comutare se realizează prin instrucţiunea switch, care are următoarea formă generală: switch (expresie) { case valoare_1: secvenţă_1
[break;] case valoare_2: secvenţă_2 [break;] .......................... case valoare_N : secvenţă_N [default: secvenţă ] } în care: - switch, case si default sunt cuvinte cheie ale limbajului Java; - expresie este o expresie de tip byte, short, int sau char; - valoare este fie un literal de tip byte, short, int sau char, fie o expresie constantă de tip int, adică o expresie care conţine numai literali sau variabile finale din tipurile menţionate; - secvenţa este o secvenţă de instrucţiuni simple sau structurate; - parantezele drepte roşii []nu apar în program, ci indică faptul că conţinutul lor este opţional (poate sa lipsească).
56. Instrucţiunea while (ciclul cu test iniţial) Această instrucţiune are forma generală while (condiţie) instrucţiune
în care condiţie - este o expresie de tip boolean; instrucţiune - poate fi orice instrucţiune (simplă sau structurată) a limbajului Java, inclusiv
altă instrucţiune while. Executarea acestei instrucţiuni se face astfel: se evaluează expresia booleană condiţie şi - dacă valoarea acesteia este true, deci condiţia este satisfacută - se execută instrucţiune ,după care se revine la evaluarea condiţiei. acest ciclu se repetă cât timp este satisfacută condiţia.
57. Instrucţiunea for (ciclul cu contor generalizat) În unele limbaje de programare, pentru realizarea ciclurilor la care numărul de paşi este dinainte cunoscut, se foloseşte o instrucţiune de control specială, numită "ciclu cu contor". În pseudocod, această instrucţiune poate fi scrisă în modul următor: pentru variabila de_la val_init la val_fin [cu_pasul pas] execută
sfârşit_ciclu
19
în care, de regulă, variabila este o variabilă (de regulă de tip întreg), numită şi contorul ciclului , val_init şi val_fin sunt respectiv valorile iniţială şi finală ale acestei variabile, iar pas este pasul de variaţie la fiecare parcurgere a ciclului. Pasul implicit este 1. În limbajul Java, urmând tradiţia limbajului C de la care acesta a preluat o bună parte a regulilor de sintaxă, se foloseşte o instructiune generalizată, prin care se realizează atât ciclul cu contor, cât şi ciclul cu test iniţial. Această instrucţiune are forma: for ([iniţializare] ; [condiţie] ; [trecere_la_pasul_următor] ) []
în care: - este formată din una sau mai multe instrucţiuni, separate prin virgule, care se execută înainte de intrarea în ciclu , astfel că sunt folosite, de regulă, pentru iniţializarea acestuia; condiţie - este o expresie de tip boolean folosită drept condiţie de continuare a ciclului cu test iniţial (condiţia este testata înainte de a se executa corpul ciclului; trecere_la_pasul_următor := instrucţiune[ ,instrucţiune]* - una sau mai multe instrucţiuni, separate prin virgule, care se execută după ce a fost executat corpul ciclului. astfel că sunt, în general, folosite pentru pregătirea trecerii la următoarea parcurgere a ciclului; - o instrucţiune (simpla sau structurată) care constituie corpul ciclului. iniţializare ::= instructiune[,instructiune]*
58. Instrucţiunea do..while (ciclul cu test final) Forma generală a instrucţiunii de control, prin care se realizează în limbajul Java ciclul cu test final este următoarea: do instrucţiune while (condiţie);
unde, la fel ca în cazul instrucţiunii while, condiţie este o expresie de tip boolean, iar instrucţiune este orice instrucţiune (simplă sau structurată) din limbajul Java. Remarcăm că la sfârşitul acestei instrucţiuni (după condiţie) se pune obligatoriu ';' (punct şi virgulă). Principala deosebire faţă de instrucţiunea while pentru ciclul cu test iniţial este că testarea condiţiei se face după ce a fost executată instrucţiunea din corpul ciclului. În consecinţă, corpul ciclului va fi executat cel puţin o dată.
59. Variabile locale şi domenii de vizibilitate Variabilele declarate într-un bloc sunt variabile locale ale blocului respectiv. Domeniul de vizibilitate al unei variabile locale începe în locul din program în care aceasta a fost declarată ş i se încheie la sfârşitul blocului care conţine declaraţia respectivă. Variabila este deci "vizibilă" (poate fi utilizată) în propriul său bloc şi în toate blocurile interioare acestuia, în domeniul de vizibilitate.
60. Tratarea excepţiilor
20
În timpul executării programului, pot apare anumite situaţii care altereaza desfăşurarea normală a acestuia. Când apare o astfel de situaţie, de regulă, se generează o excepţie sau o eroare prin care se semnalează incidentul care a avut loc. Excepţiile şi erorile pot fi generate atât de echi pamente (excepţii sau erori hardware), cât şi de programe (excepţii software). Exemple de excepţii hardware pot fi întreruperile, excepţia de împărţire la zero, unele incidente din subsistemele de intrare/ieşire etc. Excepţiile software sunt mult mai diverse, depinzând de specificul programelor care le generează. Deosebirea dintre excepţii şi erori este că excepţiile sunt considerate că pot fi tratate prin program, în timp ce erorile sunt considerate mai curând nerecuperabile. În limbajul Java, există posibilitatea de a se trata prin program diferitele excepţii care apar în timpul execuţiei. În acest fel, programatorul poate să prevadă căi alternative de continuare a executării programului, fără a mai fi necesară oprirea executării lui. În mediul de lucru Java, la apariţia unei excepţii se generează un obiect special numit excepţie, care conţine informaţia despre excepţia respectivă. Acest obiect poate fi captat prin program, iar informaţia conţinută în el poate fi utilizată pentru a decide calea pe care se va merge în continuare în derularea programului. Toate obiectele de excepţie care se referă la acela şi tip de incident formează o clasă de excepţii . Tratarea prin program a excepţiilor se face, în limbajul Java, folosind instrucţiunea try urmată de una sau mai multe clauze catch şi, opţional, de o clauză finally sub forma urmatoare: try { secventa
61. Variabile locale şi domenii de vizibilitate Variabilele declarate într-un bloc sunt variabile locale ale blocului respectiv. Domeniul de vizibilitate al unei variabile locale începe în locul din program în care aceasta a fost declarată ş i se încheie la sfârşitul blocului care conţine declaraţia respectivă. Variabila este deci "vizibilă" (poate fi utilizată) în propriul său bloc şi în toate blocurile interioare acestuia, în domeniul de vizibilitate.
62. Instrucţiuni etichetate În principiu, orice instrucţiune în limbajul Java poate purta o etichetă. Instrucţiunile etichetate au forma etichetă : instrucţiune
unde etichetă este un identificator ; instrucţiune este o instrucţiune simplă
sau structurată.
21
Exemplu
alpha: x=2*a+b; Se permite să se folosească drept etichete chiar şi identificatori care mai sunt folosiţi în acelasi program ca nume de variabile, clase, metode etc., fară a se crea prin aceasta confuzii, deoarece compilatorul face distincţie între etichete şi nume în funcţie de contextul în care acestea s unt utilizate.
63. Folosirea instrucţiunilor break şi continue Instructiunile break şi continue au forma generală următoare: break [etichetă]; continue [etichetă]; unde etichetă este eticheta unei instrucţiuni şi este un identificator . Eticheta este opţională (de aceea a fost scrisă de noi între paranteze drepte).
Instructiunea break se poate folosi în corpul unei instrucţiuni switch, while, do..while sau for şi are ca efect ieşirea forţată (abruptă) din structura de control în care se găseşte instrucţiunea respectivă. Instrucţiunea continue se poate folosi numai în corpul ciclurilor (while, do..while, for). Dacă instrucţiunea continue nu are etichetă, efectul este că se trece peste restul instrucţiunilor din corpul ciclului, începând din punctul în care se găseşte instrucţiunea continue până la sfârşitul acestuia, dar se continuă executarea ciclului, adică se reia executarea corpului acestuia cât timp este satisfacută condiţia de continuare. 64. Tipul referinţă În limbajul Java există două categorii de tipuri de date: tipuri primitive şi clase.
Tipurile primitive sunt predefinite în limbaj, în sensul că numele, mulţimea de date, mulţimea de operaţii şi reprezentarea datelor în memoria internă a maşinii virtuale Java pentru fiecare tip sunt definite în insăşi specificaţia limbajului Java şi nu mai pot fi modificate de programatori. În program, datele de tipuri primitive apar sub forma de variabile. Fiecare variabilă are un nume, un tip şi o valoare şi este plasată într-o anumita locaţie de memorie . În locaţia de memorie respectivă se găseşte chiar valoarea variabilei . Pe programator nu il interesează insă adresa de memorie la care se găseşte variabila, ci doar numele, tipul şi valoarea acesteia. Clasele sunt tipuri de date structurate specifice programării orientate pe obiecte. Clasele se definesc de programatori şi se grupează în pachete de clase. La crearea unui program nou, programatorul poate utiliza clasele din pachetele deja existente, sau poate creea propriile sale clase. În program, fiecare clasă poate avea mai multe instanţe, numite obiecte. 65. Clase, câmpuri, metode Clasa este o structură de date, asociată cu o colecţie de proceduri sau funcţii, metode, care utilizează datele din această structură. Datele unei clase se numesc câmpuri , sau variabile membre. Câmpurile pot fi statice (ale clasei) sau nestatice (ale instanţei). Când clasa este instanţiată, în memoria maşinii virtuale Java se construieşte un obiect (o instanţă a clasei respective). Obiectul conţine numai câmpuri nestatice. Câmpurile statice se păstreaza în memorie într-un singur loc, care este rezervat clasei respective.
22
Metoda este o funcţie, care întoarce o valoare şi poate avea, de asemenea, efect lateral. Ca şi câmpurile, metodele pot fi statice (ale clasei) şi nestatice (ale instanţei). Metodele statice pot invocă numai câmpurile statice ale clasei respective, în timp ce metodele nestatice pot invoca atât câmpurile statice, cât şi pe cele nestatice (ale unei instanţe a clasei respective). Dacă valoarea întoarsă de metodă este void, metoda respectivă este o procedură şi trebuie să aibă obligatoriu efect lateral. Invocarea unei metode statice (a clasei) se face printr-o expresie de forma parametri_efectivi) nume_clasa.nume_met oda(
a cărei valoare este valoarea întoarsă de funcţia respectivă. O astfel de i nvocare de funcţie poate fi deci folosită ca o componentă într-o altă expresie. De exemplu, expresia Math.sqrt(a) serveste pentru a calcula rădăcina patrată a lui a, în care scop este invocată funcţia sqrt, care este o metodă statică a clasei Math (clasa funcţiilor matematice uzuale). Putem folosi această invocare de metodă într-o expresie mai complicată, de exemplu x=2*Math.sin(a)+3; Invocarea unei metode nestatice (a instanţei) se face sub forma parametri_efectivi) referinţa_la_obiect .nume_metodă(
deci numele metodei nu mai este calificat prin (însoţit de) numele clasei, ci prin cel al variabilei referinţă la obiectul respectiv, sau prin o expresie care are ca valoare o astfel de referinţă. De exemplu, daca r1 este o variabilă referinţă care indică un anumit obiect din memorie, iar met(a)este o metodă nestatică a clasei căreia îi aparţine acest obiect, atunci r1.met(a) are ca efect invocarea metodei met pentru obiectul indicat de r1. În acest fel, metoda met(a) va folosi atât câmpurile (nestatice ale) obiectului indicat de referinţa r1, cât şi câmpurile (statice ale) clasei căreia îi aparţine acest obiect. Dacă o metoda are efect lateral , ea poate fi invocată şi sub forma de instrucţiune. Această instrucţiune constă numai din expresia de invocare a metodei, urmată de punct_şi_virgulă. În acest caz, valoarea întoarsă de metodă (valoarea expresiei) este ignorată, folosindu-se numai efectul lateral al metodei respective. Un exemplu cunoscut deja este instrucţiunea System.out.println(sir ); Este evident că metodele care întorc void (procedurile) pot fi invocate numai sub formă de instrucţiuni, fiind folosite pentru efectul lor lateral.
66. Moştenirea şi polimorfismul Moştenirea este una din proprietăţile fundamentale ale claselor în programarea orientată pe obiecte. Ea constă în faptul că dintr-o clasă se pot deriva alte clase. Clasa de baza se mai numeste şi superclasă, iar clasele derivate se numesc şi subclase. Fiecare clasă derivata moşteneşte câmpurile şi metodele superclasei. Aceasta înseamnă că toate câmpurile şi metodele existente în superclasă sunt utilizabile şi în subclasă, dar în aceasta din urmă pot exista, de asemenea, câmpuri şi/sau metode suplimentare.
Polimorfismul este o alta proprietate fundamentală a claselor. În limbajul Java este posibil ca o metodă a superclasei să fie redefinită în subclasă. Aceasta înseamnă că ea va avea în subclasă acelaşi nume şi aceeasi lista de parametri şi acelaşi tip de valoare întoarsă ca în superclasă, dar va avea un comportament diferit. 67. Constructori Constructorul este o procedură specială, prin care se construiesc obiecte dintr-o anumită clasă. Constructorul are întotdeauna acelaşi nume cu clasa. În schimb, o clasă poate avea mai mulţi constructori, care pot să difere între ei prin numărul şi/sau tipul argumentelor. Constructorul alocă în
23
memoria dinamică spaţiul necesar pentru un obiect din clasa căreia îi aparţine şi i niţializează câmpurile acestui obiect cu valori care depind de argumentele sale.
68. Ierarhia de clase Java În general, în programarea orientată pe obiecte este permisă moştenirea multiplă, adică o clasă poate avea mai multe superclase. În limbajul Java este permisă numai moştenirea simplă, deci fiecare clasă poate avea numai o singură superclasă. Această ierarhie de clase este unică, adică orice clasă are obligatoriu o superclasă şi numai una. Singura excepţie o constituie clasa Object, care este rădăcina ierarhiei de clase Java şi nu are superclasă. Vom arata ulterior că lipsa moştenirii multiple este compensată în Java prin faptul că fiecare clasa poate avea mai multe interfeţe.
69. Pachetele de clase din Java API Clasele sunt grupate în pachete (engleză: package). Pachetul este o colecţie de clase reutilizabile destinate unui anumit domeniu de utilizare, care sunt puse la dispoziţia programatorului sub formă compilată (bytecode). Ar putea fi numit şi "bibliotecă de clase", dar autorii platformei Java au preferat denumirea de pachet . Pachetul poate avea subpachete. Daca pachetul p are subpachetul q, atunci p.q este numele complet (numele calificat) al subpachetului q. Acest subpachet poate avea, la rândul sau, alte subpachete.
Java API ( Application Programming Interface - interfaţa de programare de aplicaţii) este descrierea unui set standard de pachete necesare programării în Java. Pentru pachetele conţinute în Platforma Java 2 Standard Edition (J2SE) această documentaţie poate fi gasită pe Internet la urmatoarea adresă: java.sun.com/products/j2se/1.3/docs/api/index.html - la firma Sun Microsystems; Principalele pachete de clase sunt: java.lang - conţine clasele de bază necesare programării în limbajul Java; java.io - conţine clasele necesare pentru programarea operaţiilor de intrare/ieşire; java.util - conţine clase pentru anumite structuri de date tipice (listă, stivă etc) şi alte clase utile; java.awt si javax.swing - conţin clase necesare pentru realizarea interfeţelor grafice; java.applet - pentru programarea appleturilor. Există însă şi multe alte pachete, necesare în diferite domenii de aplicaţie.
70. Declaraţia import Pentru a putea utiliza într-un fişier-sursa Java un anumit pachet (subpachet) de clase, la începutul fişierului respectiv trebuie pusă declaraţia import nume_pachet.*;
în care nume_pachet este numele calificat al pachetului respectiv. De exemplu, pentru a utiliza orice clase din pachetul java.io se pune declaraţia import java.io.*;
Pentru clasele din pachetul java.lang nu este necesară o declaraţie de import , acestea fiind importate implicit . Pentru a importa numai o anumita clasă dintr-un pachet, se foloseste declaraţia import nume_pachet.NumeClasa; De exemplu, pentru a importa clasa File din pachetul java.io se foloseşte declaraţia import java.io.File;
24
71. Utilizarea claselor din pachetul java.lang Pachetul java.lang conţine clasele fundamentale şi există pe orice platformă Java. Pentru acest pachet nu este necesară declaraţia import, clasele sale fiind importate implicit. Lista completă a claselor din pachetul java.lang şi descrierea lor se găsesc în documentaţia Java API de pe Internet. Noi vom prezenta aici câteva clase mai frecvent utilizate.
72. Clasa Object Clasa Object este rădăcina ierarhiei de clase a platformei Java . Este singura clasă care nu are o superclasă. Orice altă clasa este derivată direct sau indirect din clasa Object. Conceptual, instanţele clasei Object sunt obiecte oarecare, fără atribute precizate. Variabilele referinţă la Object se folosesc atunci când, la elaborarea programului, se consideră că lor li se pot da ca valori referinţe la orice fel de obiecte, indiferent de clasa căreia îi aparţin. În clasa Object sunt declarate, de asemenea, metode care se consideră ca trebuie să existe în toate celelalte clase. Unele din aceste metode vor trebui redefinite în clasele derivate, pentru a efectua acţiuni specifice acestor clase.
73. Clase de excepţii În pachetul java.lang există şi numeroase clase de excepţii. Instanţele acestor clase sunt creeate de către maşina virtuală Java atunci când se produce o excepţie, adică o situaţie anormală în procesul de calcul. Toate aceste clase sunt descrise în documentatia Java API. Vom menţiona aici numai două dintre ele, celelalte urmând să fie indicate la descrierea claselor care conţin metode care pot genera excepţii. În limbajul Java se face distincţie între excepţie şi eroare. Se consideră ca excepţiile sunt incidente care pot fi captate prin mecanismul try .. catch şi pot fi deci tratate prin program, în timp ce erorile sunt incidente grave, care - de regulă - nu pot fi tratate prin program ci produc oprirea executării acestuia 74. Clasa Exception Această clasă este rădăcina ierarhiei claselor de excepţii. În consecinţă, atunci când dorim ca in clauza catch sa fie captată orice fel de excepţie, scriem această clauză sub forma catch(Exception e) { instructiuni_de_tratare_a_exceptiei e
} unde e este numele simbolic (identificatorul) dat excepţiei captate. Clasa are doi constructori: public Exception() creează un obiect din clasa Exception (deci "o excepţie") care nu conţine nici un mesaj. public Exception(String s) creează un obiect din clasa Exception, care conţine un mesaj sub forma şirului s. Prin acest mesaj se indică, de regulă, ce incident a condus la generarea excepţiei respective.
75. Clasa Class O caracteristică importantă a limbajului şi platformei Java este că clasele şi interfeţele utilizate în program sunt prezente în memoria maşinii virtuale Java în timpul executării programului, sub forma de instanţe ale clasei Class. În consecinţă, se pot obţine în timpul executării unui program informaţii
25
despre clasele cărora le aparţin obiectele din memorie. Clasa Class nu are un constructor public. În schimb, putem obţine un obiect din această clasă folosind metoda getClass() a clasei Object. Există şi instanţe ale clasei Class pentru tipurile de date primitive. Acestea sunt conţinute sub forma de câmpuri statice în clasele acoperitoare ale tipurilor primitive respective. Iată câteva dintre metodele clasei Class: public String getName() - întoarce numele calificat al unei entităţi (clase, interfeţe, tip primitiv) reprezentată de un obiect din clasa Class; public boolean isAssignableFrom(Class cls) - întoarce true dacă clasa căreia i se aplică metoda este o superclasă a clasei cls, primită ca argument; public boolean isInterface() - întoarce true dacă metoda este aplicată unei instanţe a clasei Class care reprezintă o interfaţă; public boolean isPrimitive() - întoarce true dacă metoda este aplicată unui obiect din clasa Class care reprezintă un tip de date primitiv; public Class getSuperclass() - întoarce o instanţă a clasei Class care reprezintă superclasa obiectului căruia i se aplică această metodă. În fişierul TestClass.java este dat un program de testare a obţinerii obiectelor Class şi a aplicării unora dintre metodele acestora. Descrierea completă a clasei Class este dată în documentaţia Java API.
76. Clasa System Clasa System conţine câmpuri şi metode utile pentru realizarea legăturii dintre aplicaţie şi sistemul de execuţie Java (cel care implementează maşina virtuală Java). Această clasă nu poate fi instanţiată.
77. Tablouri Tabloul (în engleză Array) este o structură de date de acelasi tip, numite componente ale tabloului, care sunt specificate prin indici. În programare, tabloul poate fi privit ca o colecţie indexată de variabile de acelaşi tip. 78. Tablouri cu un singur indice Aceste tablouri corespund conceptului matematic de vector . Nu le vom numi totuşi astfel, pentru a nu face confuzie cu obiectele clasei Vector din pachetul java.util . Tabloul unidimensional este constituit dintr-un ansamblu de componente indexate (cu un singur indice), căruia i se asociază şi o variabila de tip int numita length, care reprezintă lungimea tabloului (numărul de componente). Indicii elementelor de tablou sunt cuprinşi în intervalul [0, length-1]. Utilizarea unui indice situat în afara acestui interval generează o excepţie. Întrucât tablourile sunt obiecte, pentru indicarea lor în program se folosesc variabile referinţă.
Declararea şi iniţializarea tablourilor cu un singur indice Variabilele referinţă la tablouri cu un singur indice pot fi declarate în două moduri: a/ într-o declaraţie de variabile se pune simbolul [] (o pereche de paranteze drepte) după numele variabilei referinţă la tablou. Ca exemplu, să considerăm declaraţiile următoare: int a, b, c[], d, e[];
26
String s1, ts1[], s2; În aceste declaraţii, a, b, şi d sunt variabile simple de tip double, deci ele pot primi valori simple de acest tip, iar s1 şi s2 sunt variabile referinţă la obiecte din clasa String (la şiruri de caractere). În schimb, c[] şi e[] sunt variabile referinţă la tablouri de tip int (tablouri la care toate componentele sunt de tip int), iar ts1[] este o variabilă referinţă la un tablou cu componente din clasa String.
b/ Parantezele se pun după numele tipului de date sau al clasei, în care caz toate variabilele din declaraţia respectiva sunt considerate drept referinţe la tablouri. De exemplu, în declaraţiile int[] i, j; long [] k, m; float []u, v; Str ing[] ww; variabilele i, j, k, m, u, v, ww sunt referinţe la tablouri cu componente de tipuri corespunzătoare fiecarei
declaraţii. Remarcăm că nu are importanţă dacă parantezele sunt puse imediat după numele tipului sau clasei (fară spaţiu liber) sau între acestea există unul sau mai multe spaţii.
79.Tablouri cu doi sau mai mulţi indici Tabloul cu N indici este considerat în limbajul Java drept un tablou de referinţe la tablouri cu N-1 indici. Vom exemplifica aceasta pentru cazul tabloului cu doi indici (bidimensional) şi vom extinde apoi conceptul la tablouri cu mai mult de două dimensiuni. Tablouri cu doi indici 80. Tablouri cu mai mulţi indici Modul de tratare al tablourilor cu doi indici poate fi extins şi la tablouri cu mai mulţi indici (tablouri multidimensionale). Se are în vedere ca tabloul cu N indici conţine referinţe la tablouri cu N-1 indici. De exemplu un tablou cu trei indici (tridimensional) poate fi considerat că conţine mai multe "pagini", iar fiecare "pagină" este un tablou cu doi indici (bidimensional). În acest caz, primii doi indici specifica linia şi, respeectiv, coloana, iar al treilea indice specifica "pagina" în care se găseşte o anumită componentă. Un tablou cu patru indici poate fi asemănat cu un set de "volume", în care fiecare "volum" este un tablou cu trei indici, iar cel de al patrulea indice specifica numarul "volumului" din acest set. Putem sa ne imaginam astfel si semnificaţii ale unor tablouri cu mai mult de patru indici. Totuşi, în practică, cele mai frecvent folosite tablouri au cel mult trei indici. 81. Tablouri eterogene Prin definiţie, componentele unui tablou trebuie să fie toate de acelaşi tip. În programarea orientată pe obiecte, această restricţie a fost "relaxată", în sensul că un tablou poate avea drept componente şi obiecte aparţinând claselor descendente din clasa de bază. Faptul că clasa Object este superclasă a oricărei alte clase din limbajul Java, inclusiv a claselor de tablouri, permite să se creeze tablouri eterogene, adică tablouri cu componente care aparţin unor clase foarte diferite. Acestea pot fi structuri complicate de date, realizate pornind de la structura de "tablou de obiecte" . 82. Utilizarea parametrilor din linia de comandă A venit timpul să ne ocupăm de argumentul args[] al metodei public static main(String args[]) Remarcăm ca argumentul formal args[] al acestei metode este un tablou unidimensional, ale cărui componente sunt din clasa String, deci sunt şiruri de caractere. La lansarea în execuţie a aplicaţiei, acest argument preia drept componente de tablou parametrii din linia de comandă prin care s-a făcut lansarea. Aceşti parametri pot fi, astfel, folosiţi în program după necesităţi.
83. Declararea claselor Până în prezent, s-a arătat modul în care putem utiliza în programul nostru clase existente în biblioteci (în pachetele de clase). Vom studia în continuare cum putem crea propriile noastre clase.
27
Cea mai simplă formă a unei declaraţii de clasă este următoarea: class NumeClasa { declaratii_de_membri
} Observăm că declaraţia începe cu cuvântul-cheie class, urmat de numele clasei şi de corpul clasei, cuprins între acolade.
Numele clasei este un identificator . Se obisnuieşte ca numele clasei sa înceapă cu literă majusculă. Dacă numele este compus din mai multe cuvinte, fiecare din acestea începe cu majusculă. Corpul clasei cuprinde declaraţii de membri ai clasei respective. Acestea pot fi: - declaraţii de câmpuri; - declaraţii de constructori; - declaraţii de metode. Nu este obligatoriu ca într-o clasă să existe toate aceste categorii de declaraţii. Pot exista, de exemplu, clase în care apar numai declaraţii de metode. În principiu, pot exista şi clase care conţin numai câmpuri şi nu conţin metode, deşi astfel de situaţii apar foarte rar în practică. 84. Declararea câmpurilor Declaraţiile de câmpuri servesc pentru a descrie structura de date specifică clasei respective. Câmpurile se mai numesc şi variabile membre şi pot fi ale clasei sau ale instanţei (ale obiectului). Se preferă denumirea de câmpuri, pentru a le deosebi de variabilele locale ale metodelor. Câmpurile instanţei se declară la fel ca variabilele locale ale metodelor, numai că declaraţia respectivă nu apare în blocul unei metode, ci în corpul clasei. De exemplu: int m=172, n=2*m-4, r;
Aceste câmpuri pot avea valori diferite pentru fiecare instanţă a clasei respective. În consecinţă, câmpurile instanţei sunt plasate în zona de memorie rezervată instanţei respective , astfel că ele sunt distincte pentru fiecare instanţă.
Câmpurile clasei se numesc şi câmpuri statice. Declararea unor astfel de câmpuri se face asemănător cu cea a câmpurilor de instanţă, dar declaraţia are în faţă, în acest caz, modificatorul static. De exemplu:
static double u=3.65, v=2.87*u-3.1, x;
La iniţializarea câmpurilor de instanţă se pot folosi atât valori ale câmpurilor statice, cât şi ale altor câmpuri de instanţă. În schimb, la iniţializarea câmpurilor statice se pot f olosi numai valori ale altor câmpuri statice. Câmpurile statice (ale clasei) sunt plasate în memorie în zona rezervată clasei căreia îi aparţin şi nu în cea rezervata instanţelor. În consecinţă, câmpurile clasei există în memorie într-un singur exemplar, care este accesibil fiecărei instanţe.
Valorile iniţiale implicite ale câmpurilor: dacă nu sunt iniţializate explicit, câmpurile statice şi cele nestatice primesc valori implicite astfel: - câmpurile booleene primesc valoarea false; - câmpurile numerice primesc valoarea 0 (chiar şi cele de tip char , care este tot tip numeric!); - câmpurile referinţa primesc valoarea null. Remarcăm, deci, că există o deosebire între crearea câmpurilor (variabilelor membre) şi crearea variabilelor locale. La crearea câmpurilor, acestora li se atribuie implicit o valoare iniţială, în timp ce la crearea variabilelor locale acestora trebuie sa li se atribuie valori în mod explicit . Dacă o variabilă locală apare într-o expresie fără să aibă o valoare atribuită anterior, compilatorul Java semnaleaza această situaţie ca o eroare de programare.
28
85. Declararea metodelor În programarea orientată pe obiecte, clasa conţine, în mod normal, nu numai câmpuri de date, ci şi metodele prin care se tratează aceste câmpuri. Sub aspect conceptual, metoda este o funcţie sau o procedură, care foloseşte drept date atât valorile argumentelor sale, cât şi câmpurile clasei căreia îi aparţine metoda respectivă. Cea mai simplă formă sintactică a declaraţiei de metodă este următoarea: tip_valoare_intoarsa nume_metoda (declaratii_de_argumente ) { corpul_metodei
}
în care: tip_valoare_intoarsa - este tipul valorii primitive sau clasa valorii-referinţă întoarsă de aceasta
metodă; nume_metoda- este un identificator care, în mod uzual, începe cu literă mică şi constit uie numele
metodei; declaratii_de argumente
- este o listă de declaraţii de argument separate prin virgulă, deci ea poate
avea forma: declaratie_argument1, declaratie_argument2, ... decl aratie_argumentN
dar poate fi şi vidă. Lista declaraţiilor de argument este cuprinsă între paranteze rotunde. Fiecare declaraţie de argument are forma tip_argument nume_argument
în care tip_argument - este tipul sau clasa argumentului respectiv; nume_argument - este un identificator care, în mod uzual, începe cu literă mică.
După această listă de argumente se deschide acolada unui bloc, care conţine corpul metodei, adică secvenţa de instrucţiuni prin care se calculează valoarea funcţiei respective şi/sau - dacă este cazul se efectuează acţiunile care constituie efectele laterale ale acesteia.
86. Instrucţiunea return Dacă funcţia întoarce o valoare (diferită de void), aceasta se indică prin instrucţiunea return expresie;
Efectul acestei instrucţiuni este următorul: se evalueaza expresia expresie şi se încheie executarea funcţiei respective, întorcând valoarea astfel obţinută. În consecinţă, chiar dacă după instrucţiunea return mai apar în corpul funcţiei respective şi alte instrucţiuni, acestea nu vor mai fi executate. Dacă metoda nu întoarce o valoare (întoarce void), folosirea instrucţiunii return nu este absolut necesară, încheierea execuţiei făcându-se când se ajunge la acolada prin care se sfârseşte blocul funcţiei. Totuşi, dacă este necesar să se încheie în mod abrupt executarea corpului funcţiei, se poate folosi instrucţiunea return fără expresie.
87. Metode statice La declararea metodelor statice, în faţa tipului valorii întoarse se pune modificatorul static. Metodele care conţin în declaraţie acest modificator se numesc statice sau ale clasei, spre deosebire de metodele obişnuite care sunt ale instanţei. În corpul metodelor statice se pot folosi numai câmpurile statice ale clasei respective şi se pot invoca numai alte metode statice ale acestei clase. 88. Metode cu acelaşi nume. Signatura metodei În aceeaşi clasă pot exista mai multe metode cu acelaşi nume, cu condiţia ca ele să difere prin numărul şi/sau tipul argumentelor. Pentru a deosebi între ele astfel de metode, s-a introdus conceptul de signatură.
29
Signatura metodei constă din numele acesteia, însoţit de lista de argumente. În consecinţă, două metode pot avea acelaşi nume, dacă diferă între ele prin signatură. Putem da exemple din clasele existente în pachetele deja studiate.
89. Transferul de parametri către metode La invocarea unei metode, este necesar să se transmită de la metoda care invocă la metoda invocată parametrii (argumentele) acesteia. De exemplu, la executarea invocării Math.sin(a), este necesar să se transmită către metoda sin argumentul acesteia, a. În teoria şi practica programării se cunosc diferite moduri în car se poate face transmiterea argumentelor către o funcţie sau procedură: - transmitere prin valoare: de la programul apelant către funcţie (procedură) se transmit valorile argumentelor; - transmitere prin adresa: de la programul apelant către funcţie (procedură) se transmit adresele la care se găsesc în memorie valorile argumentelor; - transmitere prin nume: de la programul apelant către funcţie (procedură) se transmit numele argumentelor; - transmitere prin referinţă: de la programul apelant la funcţie (procedură) se transmit referinţe către argumente. În limbajul Java, transmiterea parametrilor (argumentelor) metodelor se face prin valoare. Aceasta înseamnă că: - dacă argumentul aparţine unui tip de date primitiv, se transmite chiar valoarea primitivă a argumentului respectiv; - dacă argumentul aparţine unui tip-referinţă (este instanţă a unei clase), se transmite - de fapt - o referinţă către un obiect din clasa respectiva sau dintr-o clasa derivată din aceasta.
90. Metode recursive. Comparaţie între iteraţie şi recursie O metodă (funcţie sau procedură) care se invocă pe sine însăşi se numeşte metodă recursivă. Două sau mai multe metode care se invocă una pe alta (metoda A invocă metoda B şi reciproc) se numesc mutual recursive. Limbajul Java permite utilizarea metodelor recursive şi mutual recursive. Vom ilustra aceasta prin exemple. Vom arăta, de asemenea că, de regulă, aceleaşi funcţii pot fi calculate atât recursiv, cât şi iterativ (folosind cicluri). În general, în limbajele funcţionale se utilizează predominant funcţiile recursive, în timp ce în limbajele procedurale se prefera iteraţia, deşi în unele dintre ele (cum este şi limbajul Java) se pot folosi atât iteraţia, cât şi recursia. Remarcam că, la fel ca în cazul ciclurilor iterative, în metodele recursive trebuie să existe o condiţie de oprire a repetării. În caz contrar recursia ar continua până la depăşirea spaţiului de memorie alocat pentru memorarea datelor intermediare (numit stivă). Comparând metodele recursive cu cele iterative se constată că: - metodele recursive sunt "mai elegante", fiind şi mai uşor de inţeles de către om decât cele iterative; - din punct de vedere computaţional, metodele iterative sunt mai eficiente, deoarece solicită mai puţină memorie şi sunt mai rapide decât cele recursive. Deosebirea este cu atât mai mare, cu cât numărul de invocari succesive, respectiv de repetări, este mai mare.
30
91. Instrucţiunea throw Cunoaştem deja că, la apariţia anumitor anomalii în executarea programului, maşina virtuală Java generează excepţii . Excepţiile sunt obiecte din clasa Exception s-au dintr-o subclasă a acesteia. Este posibil ca programatorul să prevadă, în anumite puncte ale programului, generarea unor excepţii, folosind în acest scop instrucţiunea throw, care are forma următoare: throw new ConstructorExceptie(lista_argumente );
În limba engleză, throw este imperativul de la "a arunca". În această instrucţiune, se foloseşte operatorul new pentru a genera un obiect al clasei de excepţii căreia îi aparţine constructorul invocat, după care acest obiect este "aruncat", fie pentru a fi "prins" (captat) printr-o structura try .. catch şi tratat prin program, fie pentru a fi preluat de maşina virtuală Java care, în acest caz, opreşte execuţia programului.
92. Clauza throws În mod normal, excepţiile generate într-o metodă sunt tratate prin structuri try .. catch. chiar în metoda în care au fost generate. Este însă posibil ca metoda respectivă să "arunce" mai departe excepţiile generate în corpul ei. Pentru a indica această proprietate, la declararea metodei, după paranteza care conţine lista declaraţiilor argumentelor formale se pune clauza throws ClasaDeExceptii, în care se indică numele clasei excepţiei care este "aruncată" către metoda invocatoare (Cuvantul throws este persoana a treia singular a verbului to throw, "a arunca"). 93. Clase publice Clasele publice sunt clase care pot fi utilizate şi în alte pachete, decât cel din care fac parte. Fiecare clasă publică se declară într-un fişier separat , care are obligatoriu acelaşi nume cu cel al clasei şi extensia java. În declaraţia de clasă, în faţa numelui clasei se pune modificatorul public. Dăm în continuare ca exemplu clasa Complex.
94. Colectorul de reziduuri Dacă un obiect nu mai este necesar, el poate fi distrus, adică eliminat din memorie. În maşina virtuală Java, există un colector de reziduuri de memorie (engleză: garbage collector ) care eliberează automat spaţiul de memorie ocupat de obiectele către care nu mai există nici o referinţă . în consecinţă, programatorul nu mai este pus în situaţia să prevadă explicit în program distrugerea obiectelor şi, deci clasele nu mai conţin destructori, ca în alte limbaje de POO.
95. Metoda finalize În clasa Object exista metoda protected void finalize() throws Throwable Aceasta metodă este invocată de colectorul de reziduuri, atunci când acesta determină că nu mai există referinţe către obiectul respectiv. În clasa Object, această metodă nu efectuează nimic. Metoda finalize poate fi redefinită în orice altă clasă, pentru a elibera resurse sau a efectua orice alte acţiuni necesare înainte de distrugerea obiectului respectiv. De exemplu, dacă obiectul respectiv a deschis anumite fişiere sau conexiuni externe, în metoda finalize se poate efectua închiderea lor.
31
Metoda finalize nu este apelată explicit în programul de aplicaţie. Apelarea metodei finalize se face numai de către colectorul de reziduuri ( garbage collector ), dar nu imdeiat ce un obiect a rămas fără referinţă, ci abia atinci când acest obiect a "intrat în atenţia" colectorului. Este posibil ca executarea aplicaţiei să se incheie înainte ca "finalizarea" unor obiecte să aibă loc.
96. Caracteristicile obiectelor şi claselor În majoritatea surselor bibliografice asupra POO, se consideră drept principale caracteristici ale obiectelor încapsularea, moştenirea şi polimorfismul . La acestea se mai pot adaugă şi alte caracteristici importante, cum sunt identitatea, agregarea ş i clasificarea.
Identitatea (engleză: Identity) se referă la faptul că datele sunt grupate în entităţi discrete, numite obiecte. Fiecare obiect din POO modelează starea şi comportamentul unui anumit obiect din lumea reală, care poate fi un obiect fizic (de exemplu automobil, calculator, furnal, om, animal etc.) sau unul conceptual (de exemplu figură geometrică, orar etc.). Fiecare obiect are propria lui identitate, astfel că două obiecte sunt considerate distincte, chiar daca atributele lor (cum ar fi numele, culoarea etc.), sunt identice. Pentru a face aceasta distincţie, obiectul este indicat printr-o referinţă unică. Modul în care este reprezentata această referinţă poate sa difere în diverse limbaje de programare (de ex. adresă de memorie, nume etc.), important însă este că fiecare obiect are o singură referinţă şi nu există două obiecte distincte cu aceeaşi referinţă. Încapsularea (engleză: encapsulation) este proprietatea obiectelor de a-şi ascunde o parte din date şi metode. Din exteriorul obiectului sunt accesibile ("vizibile") numai datele şi metodele publice. Putem deci sa ne imaginăm obiectul ca fiind format din două straturi, ca în Figura 1. Agregarea (engleză: aggregation) este proprietatea obiectelor de a putea încorpora alte obiecte. Aşa dar, "datele" conţinute într-un obiect pot fi nu numai date primitive, ci şi obiecte. Se pot astfel crea obiecte cu structuri din ce în ce mai complexe. Clasificarea (engleză: classification) este proprietatea obiectelor care au aceeaşi structură de date şi acelaşi comportament (aceleaşi metode) de a putea fi grupate într-o clasă. Clasa este o abstractizare, care conţine acele proprietăţi ale obiectelor, care sunt importante într-o aplicaţie sau într-o categorie de aplicaţii, şi le ignoră pe celelalte. De exemplu, în aplicaţii privind situaţia profesională a studenţilor, clasa Student conţine astfel de atribute ca numele şi prenumele studentului, facultatea, anul de studii, examenele promovate şi notele obţinute, dar ignoră atribute ca înălţimea, culoarea ochilor sau a părului, greutatea etc., care nu sunt necesare în aplicaţia respectivă. Spre deosebire de agregare, care este o relaţie între obiecte, clasificarea este o relaţie între concepte reprezentate prin clase. Moştenirea (engleză: inheritance) este proprietatea unei clase de a conţine toate atributele (câmpurile) şi metodele superclasei sale. În consecinţă, trecerea de la clasă la subclasă se face prin adăugarea de atribute şi/sau de metode. De exemplu, clasa Barbat şi clasa Femeie au ambele toate atributele clasei Om, dar fiecare din acestea are şi atribute specifice. În general, în programarea orientată pe obiecte, moştentirea poate fi simplă sau multiplă. În cazul moştenirii simple fiecare clasă are cel mult o superclasă,
32
Polimorfismul (engleză: polymorphism) permite ca aceeaşi operaţie să se realizeze în mod diferit în clase diferite. Să considerăm, de exemplu, că în clasa Figura_geometrica există metoda arie(), care calculeaza aria figurii respective. Clasele Cerc, Triunghi, Patrat sunt subclase ale clasei Figura_geometrica si vor moşteni, deci, de la aceasta metoda arie(). Este însă evident că aria cercului se calculează în alt mod decât aria patratului sau cea a triunghiului. Pentru fiecare din instanţele acestor clase, la calcularea ariei se va aplica metoda specifică clas ei respective.
98. Modificatori de acces pentru câmpuri şi metode În limbajul Java există trei modificatori de acces pentru câmpuri şi metode: - private - pentru a specifica câmpuri sau metode private; - public - pentru a specifica câmpuri sau metode publice; - protected - pentru a specifica câmpuri sau metode protejate (care vor fi prezentate în secţiunea despre moştenire). Membrii privati ai claselor (câmpuri sau metode) sunt accesibili numai din clasa respectivă. Membrii publici sunt accesibili din orice clasă. Membrii protejati sunt accesibili numai din clasa în care se află sau din subclasele acesteia. Dacă la declararea câmpurilor sau metodelor nu se folosesc modificatori de acces, acestea sunt considerate vizibile numai din clasele care sunt situate în acelaşi pachet cu clasa căreia îi aparţin. În particular, pentru clasele declarate de către noi, aceste câmpuri şi metode sunt vizibile numai din clasele situate pe disc în acelaşi director. Se spune, în astfel de cazuri, că modul de acces este prietenos (engleză: friendly) sau de pachet (engleză: package).
99. Referinţele this şi super În orice clasă pot fi utilizate două referinţe predefinite: this - este o referinţă la "această" instanţă, adică la instanţa (obiectul) din care se face referinţa respectivă; super - este o referinţă la superclasă. 100. Declararea clasei derivate. Clauza extends În declaraţia clasei derivate (subclasei), numele clasei care se declară este urmat de clauza extends, în care se indică numele superclasei . În consecinţă, clasa derivată poate fi declarată astfel: class NumeClasa extends NumeSuperclasa { declaratii_de_membri
} Amintim că în limbajul Java orice clasă are o superclasă şi numai una . Excepţie face clasa Object, care este rădăcina ierarhiei de clase. Daca lipseşte clauza extends, superclasa implicită este Object.
101. Declararea constructorului clasei derivate Pentru a se da valori iniţiale câmpurilor superclasei, în declaraţia constructorului subclasei poate fi invocat constructorul superclasei prin instrucţiunea super(lista_parametri_efectivi );
unde lista parametrilor efectivi este cea a constructorului superclasei. Aceasta instrucţiune, dacă există, trebuie să fie prima instrucţiune din corpul constructorului clasei derivate. În lipsa ei, va fi invocat constructorul fără parametri al superclasei.
33
Este posibil, de asemenea, ca într-un constructor să se invoce alt constructor al aceleeaşi clase , sub forma this(lista_parametri_efectivi );
102. Metode finale Metodele finale sunt metode care nu mai pot fi redefinite în clasele derivate. Astfel de metode se declară cu modificatorul final. De exemplu, în clasa Object, metoda getClass este o metoda finală, fiind declarată sub forma public final Class getClass(). Aceasta inseamnă că în nici o altă clasă nu este posibil ca aceasta metodă să fie redefinită. Când declarăm propriile noastre clase, avem şi noi posibilitatea să declarăm că unele din metodele lor sunt finale.
103. Clase finale Dacă se doreşte ca o clasă să nu poată avea subclase, la declararea acesteia se foloseşte modificatorul final. De exemplu, dacă se dorea ca clasa CD1, dată ca exemplu mai sus, să fie finala, ea trebuia declarata sub forma public final class CD1 extends S1 sau, dacă nu se dorea sa fie publica, sub forma final class CD1 extends S1
104. Redefinirea metodelor Metodele de instanţă (nestatice) ale unei clase pot fi redefinite în subclasele acesteia. Redefinirea unei metode se face declarând în subclasă o metodă având aceeaşi signatură cu una din superclasă. Atunci când se redefineşte o metoda protejată, modificatorul de acces al acesteia poate fi menţinut, sau poate fi transformat în public. În subclasă pot fi folosite, totuşi, şi metodele superclasei care au fost redefinite, dacă la invocarea acestor metode se foloseste referinţa super .
105. Ascunderea câmpurilor Câmpurile declarate într-o clasă pot fi ascunse prin câmpuri cu acelaşi nume declarate în subclasă, chiar dacă acestea au tipuri diferite. Aceasta înseamna că, în mod normal, în metodele clas ei se folosesc câmpurile declarate în clasa respectivă, şi nu cele cu acelaşi nume ale superclasei. În subclasă pot fi, totuşi, folosite şi câmpurile superclasei, dacă sunt calificate cu referinţa super . 106. Ascunderea metodelor statice Metodele statice nu aparţin instanţelor, ci clasei. Din această cauză, dacă într-o subclasă se declara o metoda statică cu aceeaşi signatură ca o metodă a superclasei, atunci se spune că metoda din subclasă o ascunde pe cea din superclasă (nu o redefineşte). Modul de lucru cu metodele ascunse este similar cu cel în care se lucrează cu câmpurile ascunse. Vom înţelege mai bine deosebirea dintre redefinire şi ascundere când vom studia polimorfismul .
107. Instanţierea clasei care conţine metoda main Clasa care conţine metoda main este clasa principală a unei aplicaţii, deci este prima clasă care se încarcă în maşina virtuală Java la punerea în execuţie a aplicaţiei respective. În acelaşi timp, ea este o clasă ca oricare alta, care poate avea şi instanţe. Metoda main(), fiind statică, nu poate utiliza direct decât câmpurile statice şi metodele statice ale acestei clase. Totuşi, în metoda main() sau în alte metode, pot fi create instanţe ale acestei clase, putându-se astfel utili za şi câmpurile şi metodele de
34
instanţă ale acestora.
108. Clase abstracte Clasele abstracte conţin în declaraţia lor modificatorul abstract. Clasele abstracte nu pot fi instanţiate. Remarcăm însa că pot exista clase care nu pot fi instanţiate deşi nu sunt abstracte, cum sunt, de exemplu, clasele care nu au decât constructori privaţi. Cu toate că clasa abstractă nu poate fi instanţiată, se pot declara variabile aparţinând unor clase abstracte. Acestor variabile li se pot da însa ca valori numai referinţe către instanţe ale unor subclase concrete. De exemplu, daca A este o clasă abstracta, iar B este o subclasă concreta a clasei A, atunci este corectă declaraţia A a1=new B();
Declararea unei metode abstracte: - antetul metodei trebuie sa conţina modificatorul abstract; - corpul metodei se înlocuieşte prin caracterul ';' (punct şi virgulă).
109. Interfeţe Conform principiului încapsulării, fiecare clasă are "interfaţa" sa intrinsecă, prin care poate fi accesata din exterior. Aceasta "interfaţă" conţine toate datele şi metodele publice ale clasei respective. Pentru a compensa lipsa moştenirii multiple, în limbajul Java s-a admis că o clasă poate avea mai multe interfeţe şi că mai multe clase pot implementa aceeaşi interfaţă. S-a introdus astfel o nouă categorie de componente, numite interfeţe, care se declară în mod asemănător cu nişte clase abstracte, dar nu sunt înglobate, aşa cum sunt clasele abstracte, în ierarhia unică de clase . Interfaţa este o specificaţie care descrie metodele publice şi variabilele finale publice pe care trebuie sa le aibă o clasă care implementeaza interfaţa respectivă. Dacă o clasă implementează mai multe interfeţe, ea conţine toate metodele publice şi variabilele finale publice ale acestora. Interfaţa nu este o clasă, dar poate fi utilizată de programator ca şi când ar fi o clasă abstractă. Se pot declara variabile referinţă la o interfaţă în mod asemănător cu declararea variabilelor referinţa la obiecte aparţinând unei clase, adică sub forma: interfaţa nume_variabila1[=initializare1], ..., nume_variabilaN [=initializareN ];
în care interfaţa este numele unei interfeţe, iar celelalte elemente ale declaraţiei sunt aceleaşi ca în cazul declarării de referinţe la obiecte. Interfeţele pot fi şi ele organizate ierarhic, aplicându-se principiul moştenirii. În schimb, pentru interfeţe, ierarhia nu mai este unică, aşa cum este în cazul claselor, şi se admite moştenirea multiplă. v4=(B)w1;
110. Declararea interfeţelor O declaraţie de interfaţă introduce un nou tip referinţă, ai cărui membri sunt câmpuri statice finale şi metode abstracte. În consecinţă, interfaţa se aseamănă cu o clasa abstractă pură , care nu conţine decât metode abstracte şi câmpuri statice finale şi nu se încadrează în ierarhia unică de clase descendente din Object (amintim ca o clasa abstractă, în afară de una sau mai multe metode abstracte, poate conţine şi câmpuri de date şi metode concrete şi este descendentă a clasei Object).
35
Deşi nu se încadrează în ierarhia claselor, interfeţele se pot constitui in diverse ierarhii de interfeţe, aplicându-li-se principiul mostenirii. O clasă poate implementa mai multe interfeţe. Cel mai important avantaj al folosirii interfeţelor este că mai multe clase, de pe diferite ramuri ale arborelui ierarhic al claselor, pot fi "văzute" printr-o singură interfaţă. Se pot declara variabile referinţă la interfaţă la fel cum se pot declara variabile referinţă la clasă. Interfaţa este abstractă şi deci nu poate fi instanţiată. În schimb, unei variabile referinţă la interfaţă i se pot atribui ca valori referinţe la obiecte din orice clasă care implementează interfaţa respectivă. Declaraţia de interfaţă are forma generală următoare: [public] interface NumeInterfata [extends lista_superinterfete] { declaratii_de_membri_ai_interfetei
} Spre deosebire de clase, la care moştenirea multiplă este interzisă (o clasă poate avea numai o singura superclasă), în cazul interfeţelor moştenirea multiplă este permisă . În consecinţă, clauza extends poate conţine o listă de nume de interfeţe separate prin virgule.
111. Clase imbricate şi clase interioare În limbajul Java se permite ca o clasă să aibă ca membri alte clase. Acestea se numesc clase imbricate sau clase încuibate (engleza: nested classes). Ca şi ceilalţi membri, clasele imbricate pot fi statice sau nestatice şi se declară în corpul clasei care le încorporează. Clasele imbricate nestatice se numesc clase interioare (engleză: inner classes). O clasă care încorporează (imbrică) alte clase se declară astfel: [public] class NumeClasa
{ declaratii_de_membri_ai_clasei [modificatori_de_camp] class NumeClasaImbricata { declaratii_de_membri_ai_clasei_imbricate
} declaratii_de_membri_ai_clasei
}
Se recurge la aceasta tehnică atunci când utilizarea unei clase are sens numai în cadrul altei clase. Aşadar, prin imbricare se creează o legatură strânsa între două clase. Este posibil, desigur, ca o clasa să conţină mai multe clase imbricate. Remarcăm că declaraţia clas ei imbricate este tratata ca oricare alta declaraţie de membru al clasei, putând avea şi modificatori de câmp (de exemplu static). Fiind membru al clasei, clasa imbricată are acces la toţi membrii clasei care o conţine, chiar şi la cei privaţi. Dacă clasa imbricată este statică, ea nu poate referi direct decât membrii statici ai clasei care o conţine. Clasa imbricată statică există, la fel ca şi câmpurile sau metodele statice, numai în cadrul clasei care o conţine, nu şi în instanţele acesteia. În consecinţă, pentru a referi membrii acestei clase, se foloseşte pentru calificare numele clasei. Clasa interioară (clasa imbricată nestatică) are câte o instanţă în interiorul fiecărei instanţe a clasei care o conţine. În consecinţă, accesul la membrii ei se poate face folosind drept calificator referinţa la o instanţă. Clasa interioară are acces la toţi membrii clasei care o conţine, atât la cei statici, cât şi la cei de instanţă (nestatici).
36
112. Clasa String public final class String extends Object implements Serializable, Comparable
Instantele clasei String sunt siruri de caractere. Orice literal sir in limbajul Java, de exemplu "abc", este un astfel de obiect. Sirurile sunt constante, deci continutul lor nu poate fi modificat. Pentru a obtine siruri modificabile se va folosi clasa StringBuffer .
Nota: amintim ca in limbajul Java reprezentarea interna a caracterelor se face pe 16 biti, i n Unicode. Campuri: public static Comparator CASE_INSENSITIVE_ORDER Campul contine un Comparator care ordoneaza obiectele-sir cand ele sunt comparate cu metoda
comparetoIgnoreCase(). Constructori: public String() Creeaza un sir vid. public String(byte[] bytes) Creeaza un obiect al clasei String care contine caracterele din tabloul de octeti primit ca argument. Se considera ca in acest tablou caracterele sunt reprezentate pe 8 biti, in codul local valabil pe calculatorul pe care se executa programul. Daca referinta la tablou este nula se genereaza o NullPointerException.
112. Clasa StringBuffer public final class StringBuffer extends Object implements Serializable
Un StringBuffer implementeaza un sir de caractere care poate fi modificat. El reprezinta o zona tampon din memorie, in care se ppoate plasa un sir de caractere. Operatiile principale asupra unui StringBuffer sunt metodele append si insert. Fiecare din ele converteste o data intr-un String, pe care apoi il adauga la sirul din StringBuffer sau il insereaza in acesta pe o pozitie data. Fiecare StringBuffer are o capacitate si o lungime. Lungimea este numarul efectiv de caractere continute, iar capacitatea este numarul maxim de caractere care incap in zona tampon rezervata in memorie. Daca, printr-o noua adaugare de caractere, lungimea depaseste capacitatea, atunci capacitatea se mareste in mod automat.
113. Clasa Math public final class Math extends Object
Clasa Math contine metode statice pentru calcularea unor functii matematice uzuale, cum sunt functiile trigonometrice, radacina patrata si altele.
37
Campuri: public static final double E - numarul e (baza logaritmilor naturali); public static final double PI - numarul pi (raportul dintre circumferinta cercului si diametru).
Metode: public static double sin(double a)- intoarce sinusul trigonometric sin a, unde unghiul a este in radiani. public static double cos(double a)- intoarce cosinusul trigonometric cos a, unde unghiul a este in radiani; public static double tan(double a)- intoarce tangenta trigonometrica tg a, unde unghiul a este in radiani;
114. Interfeţe utilizator grafice Interfaţa utilizator , numită şi interfaţa om-maşină, este mijlocul de comunicare între un sistem informatic şi utilizator. În programare, conceptul de interfaţă utilizator a apărut în legătură cu utilizarea programelor în regim interactiv. Un asemenea regim permite utilizatorului să comunice cu procesul de calcul în timpul desfăşurării acestuia. În prezent, se cunosc două tipuri principale de interfeţe utilizator: - interfaţa prin linie de comandă; - interfaţa grafică. În modul de comunicare prin linie de comandă, operatorul uman transmite calculatorului comenzi , pe care le introduce de la tastatură sub forma unor linii de text , folosind un anumit limbaj de comandă . Exemplele cele mai cunoscute sunt limbajele de comandă ale sistemelor de operare MS-DOS şi Unix.
Interfaţa utilizator grafică (engleză: GUI - graphical user interface) este o interfaţă om-maşină care permite operatorului să dea comenzi şi să introducă date prin acţionarea asupra unor obiecte grafice vizualizate pe ecran: butoane, pictograme, meniuri etc. Un avantaj important al platformei Java 2 este că oferă pachete de clase, care permit programatorului realizarea comodă şi eficientă a interfeţelor grafice. În prezent, există două grupuri de pachete de clase pentru interfeţe grafice, care corespund la două principii diferite de realizare a interfeţei: 1. AWT (engleză: Abstract Windowing Toolkit - setul de dezvoltare de ferestre abstracte) - este un set de clase care permit realizarea de interfeţe grafice în care se folosesc obiectele grafice specifice platformei pe care se execută programul. Aceasta înseamnă că, dacă programul se execută - de exemplu - sub Windows, diferitele obiecte grafice (butoane, meniuri, bare de defilare etc.) vor avea aspectul specific sistemului Windows, în timp ce dacă se executa sub X-Window vor avea aspectul specific acestui sistem. 2. JFC (engleză: Java Foundation Classes - clase de bază Java), este un set de pachete de clase, care extind posibilităţile oferite de AWT, pentru realizarea de interfeţe utilizator de calitate superioară. Dintre acestea, cele mai larg folosite constituie setul cunoscut sub numele de cod Swing
38
(sau JFC/Swing), care oferă posibilitatea de a realiza interfeţe grafice al căror aspect nu depinde de platforma pe care se execută programul.
115. Clasa Component Având în vedere că întreaga ierarhie de clase de obiecte de interfaţă utilizator grafică folosite în Java (atât cele din AWT, cât şi din JFC/Swing) are ca rădăcină clasa Component, este util să începem studiul cu această clasă. Componenta este un obiect grafic care este afişabil pe ecran şi poate interacţiona cu utilizatorul. Clasa Component este o clasă abstractă, derivată direct din clasa Object. Dintre numeroasele metode ale acestei clase, prezentăm aici numai câteva mai frecvent folosite: public boolean isVisible() - testează dacă această componentă este vizibilă, atunci când este vizibil şi containerul în care se găseşte; public void setVisible(boolean visible) - face componenta sa fie vizibilă sau nu, după cum argumentul este true sau false; În aceste metode se utilizează şi clasele auxiliare Point şi Dimension din pachetul java.awt. Instanţele clasei Point conţin coordonatele unui punct. Se consideră că originea sistemului de coordonate se află în colţul din stânga sus, axa Ox este orientată către dreapta, iar axa Oy este orientata în jos. Instanţele clasei Dimension conţin dimensiunile componentei: lăţimea şi înălţimea.
116. Clasa JFrame public class JFrame extends Frame implements WindowConstants, Accessible, RootPaneContainer Este varianta Swing a clasei Frame din AWT, fiind o subclasă a acesteia. O deosebire importantă între cele două clase este că, în clasa JFrame, componentele nu se mai adaugă direct la fereastra (la frame), ci la un panou conţinut de aceasta, numit contentPane. O referinţă la contentPane se obţine prin metoda getContentPane(). Operaţiile cu acest contentPane (adăugarea şi eliminarea de componente, setarea gestionarului de poziţionare etc) se fac folosind metodele clasei Container. Constructori public JFrame() - construieşte un JFrame, iniţial invizibil şi fără titlu. public JFrame(String title) - construieşte un JFrame, iniţial invizibil, cu titlul specificat. public JFrame(GraphicsConfiguration gc) - construieşte un JFrame fără titlu, cu configuraţia grafică specificată, iniţial invizibil. public JFrame(String title, GraphicsConfiguration gc) - construieşte un JFrame cu titlul şi configuraţia grafică specificate, iniţial invizibil.
117. Programarea orientată pe evenimente Când se lucrează cu o interfaţă grafică, pe ecranul staţiei de lucru apar diferite obiecte grafice: ferestre, meniuri, butoane, bare de defilare etc. Operatorul poate utiliza tastatura staţiei de lucru, la fel ca în cazul progrămarii tradiţionale, dar, în plus, utilizează un dispozitiv de selecţie numit mouse, cu
39
ajutorul căruia poate alege diferite obiecte grafice de pe ecran şi poate da anumite comenzi prin apăsarea unuia din butoanele acestui dispozitiv. Se numeste eveniment orice modificare care are loc, fie în starea dispozitivelor de intrare, fie în cea a obiectelor grafice de pe ecran: apăsarea sau eliberarea unei taste, deplasarea mouse-ului, apăsarea sau eliberarea unui buton al mouse-ului, deschiderea sau închiderea unei ferestre, efectuarea unui clic de mouse pe un obiect de control (buton, caseta de validare, bara de defilare etc.), intrarea cursorului de mouse în câmpul activ al unui obiect grafic sau părăsirea acestuia etc. Pot exista, desigur, şi alte tipuri de evenimente, dar aici ne interesează numai cele legate de interfaţa grafică a aplicaţiei.
Interacţiunea dintre operator şi aplicaţie într-un sistem bazat pe evenimente decurge astfel: operatorul provoacă generarea unui eveniment, acţionând asupra tastaturii, mouse-ului sau a altui dispozitiv de intrare, iar programul "răspunde" la acest eveniment prin executarea unei anumite acţiuni. Acest mod de lucru impune o nouă concepţie în proiectarea programelor, numită programarea orientată pe evenimente. Există diferite modele de generare, captare şi tratare a evenimentelor. În lucrarea de faţă va fi prezentat modelul de evenimente specific platformei Java 2.
118. Clase de evenimente Clasele de evenimente se găsesc în pachetele java.awt.event şi javax.swing.event şi formează o ierarhie de clase, care are ca radacină clasa abstractă java.awt.AWTEvent. Aceasta, la rândul ei, extinde clasa java.util.EventObject din pachetul java.util. Orice eveniment conţine următoarele metodele declarate în clasa java.util.EventObject: public Object getSource() - care întoarce o referinţă către obiectul care a generat evenimentul respectiv; public String toString() - care întoarce o reprezentare sub forma de şir a obiectului. Orice eveniment AWT (generat de componente AWT sau JFC/Swing) conţine un câmp protejat de tip int numit id, a cărui valoare indică tipul evenimentului. Toate clasele de evenimente conţin câmpuri statice finale de tip int, al căror nume indică tipul de eveniment şi a căror valoare este valoarea corespunzătoare a câmpului id. Valoarea acestui câmp se poate obţine prin metoda public int getId() Evenimentele pot fi de nivel coborât ( low level event ) sau semantice. Numele claselor de evenimente de nivel coborât indică fie componenta, fie dispozitivul de intrare care le-a generat, de exemplu: ComponentEvent, WindowEvent, MouseEvent, KeyEvent. Numele claselor de evenimente semantice indică mai curând tipul de eveniment, decât sursa acestuia, de exemplu: ActionEvent, TextEvent. Descrierea claselor de evenimente este dată complet în documentaţia Java API.
119. Interfeţe şi clase adaptoare pentru ascultători de evenimente Evenimentele generate de surse, sunt captate şi tratate de ascultători. Sursele sunt componente ale interfeţei grafice care, de regulă, sunt preluate din pachetele de clase ale platformei Java 2, deci nu sunt programate de către programatorul de aplicaţie, ci doar utilizate de acesta. În schimb, programatorul de aplicaţie trebuie să creeze clasele de ascultători de evenimente specifice aplicaţiei pe care o dezvoltă. Metodele acestor clase trebuie sa reacţioneze la apariţia evenimentelor şi să execute acţiunile corespunzătoare, conform cu obiectivele aplicaţiei. În consecinţă, platforma Java 2 nu pune la dispoziţie clase ascultătoare predefinite, ci doar interfeţele pe care trebuie să le implementeze aceste clase, pentru a putea trata evenimentele pe care le recepţionează.
40
Există câte o interfaţă de ascultător pentru fiecare clasă de eveniment. De exemplu, pentru ComponentEvent există interfaţa ComponentListener, pentru WindowEvent exista intefaţa WindowListener etc. Pentru a se uşura munca programatorilor, pentru unele interfeţe care conţin mai multe metode, se oferă şi prototipuri de clase care implementează interfaţa respectivă, numite adaptoare. De exemplu, clasa WindowAdapter implementează
120. Evenimentele generate de o fereastră Pentru a ne familiariza cu modelul de evenimente al platformei Java 2, vom urmări acum evenimentele generate de o fereastră şi modul cum acestea pot fi tratate. Vom folosi în acest scop o interfaţă din clasa javax.swing.JFrame. Aceasta este derivată din clasa java.awt.Frame care, la rândul ei, este derivată din clasa java.awt.Window. Evenimentele prezentate în această secţiune sunt generate de orice instanţă a clasei Window şi ale subclaselor sale. Evenimentele generate de fereastră sunt instanţe ale clasei WindowEvent şi sunt ascultate de instanţe ale unor clase care implementează interfaţa WindowListener sau extind clasa WindowAdapter. Toate aceste clase şi interfeţe se găsesc în pachetul java.awt.event . Pentru a se trata evenimentele generate de fereastră, este necesar să se declare o clasă care implementează interfaţa WindowListener. În această clasă se definesc toate metodele interfeţei, astfel încât acestea să execute acţiunile adecvate evenimentelor corespunzătoare.
121. Terminarea aplicaţiei la închiderea ferestrei Pentru ca la acţionarea butonului de închidere din colţul din dreapta-sus al ferestrei să se închidă nu numai fereastra respectivă, ci si aplicaţia, este necesar ca metoda windowClosing() a ascultătorului de fereastră să conţină invocarea metodei System.exit(0) din clasa System. Dacă nu dorim să utilizam şi alte metode de tratare a evenimentelor generate de fereastră, vom deriva clasa de ascultare a ferestrei AF din clasa WindowAdapter. 122. Evenimente de mouse Evenimentele de mouse sunt instanţe ale clasei java.awt.event.MouseEvent şi sunt generate de către orice componentă a interfeţei grafice, atunci când asupra ei se acţioneaza cu mouse-ul. Clasa MouseEvent este derivată din clasa java.awt.event.InputEvent. Evenimentele de mouse sunt intrarea cursorului de mouse într-o componentă sau ieşirea din aceasta, apăsarea unui buton de mouse sau eliberarea lui, efectuarea unui click de mouse (simplu sau multiplu) pe suprafaţa componentei, mişcarea mouse-ului. În AWT se face distincţie între evenimentele de mouse discrete şi evenimentele care caracterizează mişcarea continuă a mouse-lui. a/ Evenimente de mouse - a fost apăsat un buton al mouse-ului (MOUSE_PRESSED); - a fost eliberat un buton al mouse-ului (MOUSE_RELEASED); - s-a făcut click de mouse, adică un buton al acestuia a fost apăsat şi eliberat imediat (MOUSE_CLICKED); - cursorul mouse-ului a intrat într-o componentă (MOUSE_ENTERED); - cursorul mouse-ului a ieşit din componentă (MOUSE_EXITED). Ascultarea acestor evenimente se face cu instanţe ale claselor care implementeaza interfaţa java.awt.event.MouseListener. b/ Evenimente de mişcare a mouse-ului
41
- mouse-ul s-a mişcat pe suprafaţa componentei (MOUSE_MOVED); - mouse-ul a fost "tras" pe suprafaţa componentei, adică a fost mişcat ţinând un buton apăsat (MOUSE_DRAGGED). Aceste evenimente sunt ascultate cu instanţe ale claselor care implementează interfaţa java.awt.event.MouseMotionListene
123. Evenimente de tastă De câte ori se apasă sau se eliberează o tastă, componenta activă a interfeţei grafice generează un eveniment de tastă din clasa java.awt.event.KeyEvent. Acesta poate fi tratat cu un "ascultător de taste" care implementează interfaţa java.awt.event.KeyListener sau care extinde clasa java.awt.event.KeyAdapter. Se disting următoarele evenimente generate la acţionarea tastelor: - a fost apasată o tastă (KEY_PRESSED); - a fost eliberată o tastă (KEY_RELEASED); - a fost "tipărit" un caracter, adică a fost apasată şi eliberată o tastă care transmite un caracter tipăribil (KEY_TYPED). Aceste situaţii pot fi detectate cu metodele corespunzătoare ale interfeţei KeyListener. Evenimentul generat de tastă conţine, în afară de codul tastei acţionate, şi informaţii privind starea tastelor auxiliare Ctrl, Alt şi Shift în momentul producerii evenimentului respectiv. Aceste stări pot fi detectate cu metodele corespunzătoare ale interfeţei superclasei java.awt.event.InputEvent.
124. Adăugarea unei componente la fereastra principală a aplicaţiei Până în prezent, am arătat că, atunci când folosim JFC/Swing, fereastra principală a aplicaţiei este o instanţă a clasei javax.swing.JFrame sau a unei subclase a acesteia. Pentru a construi o interfaţă utilizator grafică este necesar ca în fereastra principală să introducem diverse componente. Acestea pot fi componente simple, ca etichete, butoane, casete de validare, câmpuri de text etc., sau pot fi containere, care conţin - la rândul lor - alte componente. Pentru realizarea acestor componente simple şi containere se folosesc clasele din pachetele java.awt şi javax.swing, care sunt descrise în documentaţia Java API. Adăugarea de componente nu se face direct la instanţele clasei JFrame. În JFrame există un Container (un obiect dintr-o subclasă a clasei Container) numit contentPane, la care se pot adăuga componente. O referinţă la acest Container se obţine prin metoda public Container getContentPane(), existentă în clasa JFrame. Adăugarea de componente se face prin una din metodele add() ale clasei Container. Dacă, de exemplu, comp este referinţă la o componentă, atunci expresia getContentPane().add(comp), folosită într-o metodă a clasei JFrame sau a subclaselor ei, adaugă componenta comp la containerul contentPane conţinut în JFrame.
125. Gestionarea poziţionării componentelor Am arătat în secţiunea precedentă cum se poate plasa într-un container (în particular într-un contentPane) o singură componentă. În mod normal însă, într-un comtainer se plasează mai multe componente. În acest caz, este foarte important să se stabilească modul în care aceste componente sunt poziţionate pe suprafaţa containerului. În acest scop, a fost introdus conceptul de gestionar de poziţionare (în engleză: Layout Manager ).
42
Gestionarul de poziţionare este o clasă care asigură poziţionarea şi redimensionarea automată a componentelor situate într-un container, atât la crearea containerului, cât şi la modificarea dimensiunilor acestuia. Orice gestionar de poziţionare implementează interfaţa java.awt.LayoutManager sau subinterfaţa acesteia java.awt.LauoutManager2. În cele ce urmează, vom studia cele mai larg utilizate clase de gestionare a poziţionării, existente în pachetele java.awt şi javax.swing. Fiecare clasă de container are un gestionar de poziţionare implicit. Acesta este BorderLayout pentru Frame şi JFrame.contentPane şi FlowLayout pentru clasa Panel. Modificarea gestionarului de pozitionare se face prin metoda public void setLayout(LayoutManager manager)
din clasa java.awt.Container.
126. Clasa BorderLayout Începem cu această clasă, deoarece este gestionarul de poziţionare implicit pentru conţinutul instanţelor clasei JFrame. În acest caz, se consideră că suprafaţa containerului este imparţită în cinci zone numite, respectiv, NORTH, SOUTH, WEST, EAST si CENTER. În fiecare din aceste zone se poate plasa numai o singură componentă, care poate fi însă ea însăşi un container. Adăugarea de componente la container se face, în acest caz, folosind metoda add(componenta , BorderLayout.ZONA ), unde componenta este referinţa la componenta adaugată, iar ZONA este una din cele cinci zone menţionate mai sus. Dacă se foloseşte metoda add(componenta ), fără a indica zona, componenta respectivă este plasată implicit în zona CENTER, aşa cum s-a procedat în secţi unea precedenta, în exemplul din fişierul AdComp.java. 127. Clasa FlowLayout Gestionarul de poziţionare java.awt.FlowLayout plasează componentele pe suprafaţa containerului una după alta, în ordinea în care acestea sunt adăugate, de la stânga la dreapta şi de sus în jos. Când sa terminat o linie, se trece la linia următoare. Numărul de componente pe o linie depinde de l ăţimea componentelor şi de lăţimea containerului în care sunt acestea plasate. Este posibil să se specifice modul de aliniere a componentelor: la stânga, la dreapta sau la centru. Aceasta se face fie specificând alinierea ca argument al constructorului, fie invocând metoda public void setAlignement(int align)
în care argumentul align poate fi FlowLayout.LEFT, FlowLayout.RIGHT sau FlowLayout.CENTER . Remarcăm că aplicaţia ButoaneF este o modificare a aplicaţiei Butoane din fişierul Butoane.java şi se deosebeşte de aceasta prin următoarele: - în metoda main se preia un argument din linia de comandă, care trebuie să fie numărul de butoane de acţionare solicitat de utilizator, după care se construieşte fereastra aplicaţiei; - s-a introdus tabloul bc[] care conţine referinţe la instanţele clasei ButonContor. Atât acest tablou, cât şi butoanele respective, se creează în constructorul clasei IUG; - după adăugarea butoanelor de contorizare, se adaugă la fereastra aplicaţiei butonul de anulare br, din clasa JButton; - pentru ascultarea acţionării butonului de anulare, a fost declarată clasa imbricată Anulare, care implementează interfaţa ActionListener.
128. Clasa GridLayout Gestionarele de poziţionare din clasa java.awt.GridLayout plasează componentele în celulele unei grile rectangulare. În consecinţă, toate componentele de pe aceeaşi coloană sunt aliniate vertical.
43
Clasa are doi constructori: public GridLayout(int rows, int cols) - are ca argumente numărul de linii şi de coloane al grilei; public GridLayout(int rows, int cols, int hgap, int vgap) - are în plus ca argumente spaţiul orizontal şi,
respectiv, vertical între componente. Deşi în constructor se indică atât numărul de linii, cât şi cel de coloane ale grilei, în realitate numai numărul de linii este respectat, în timp ce numărul de coloane este practic ignorat. La stabilirea amplasării componentelor în container, dacă numarul lor total este mai mic sau egal cu cel de linii, toate componentele vor fi aşezate vertical, una sub alta. Dacă numărul de componente este mai mare decât numărul de linii, numărul de coloane se stabileşte automat, prin împărţirea numărului de componente la cel de linii, cu rotunjire în plus. Plasarea efectivă a componentelor în celulele grilei astfel creeate se face apoi de la stânga la dreapta şi de sus in jos, la fel ca în cazul gestionarului FlowLayout, dar respectând alinierea verticală şi orizontală impusă de grilă.
129. Clasa BoxLayout Gestionarul de poziţionare javax.swing.BoxLayout plasează toate componentele containerului pe o singură direcţie, care poate fi orizontală sau verticală. Constructorul clasei este public BoxLayout(Container target, int axis) în care target este o referinţa la containerul ţintă (al cărui gestionar de poziţionare este creat), iar axis poate fi BoxLayout.X_AXIS sau BoxLayout.Y_AXIS şi indică direcţia (axa) după care vor fi plasate componentele. În loc de a folosi gestionarul BoxLayout într-un container oarecare, se preferă să se foloseasca clasa javax.swing.Box, care are acest gestionar implicit.
130. Clasa CardLayout public class CardLayout extends Object implements LayoutManager2, Serializable Instanţele acestei clase sunt gestionari de poziţionare, care plasează componentele în container una peste alta, ca într-un pachet de cărţi de vizită.La un moment dat este vizibilă numai componenta de deasupra, însă componentele îşi pot schimba locurile între ele prin rotaţie.
Constructori public CardLayout() - construieşte un CardLayout fără spaţiu liber în jurul componentelor. public CardLayout(int hgap, int vgap) - construieşte un cardLayout care are pe margini spaţiile libere hgap pe orizontală şi vgap pe verticală.
Metode Metodele interfeţelor LayoutManager şi LayoutManager2 , la care se adaugă următoarele:
public int getHgap() - întoarce spaţiul liber pe orizontală. public void setHgap(int hgap) - setează spaţiul liber pe orizontală. public int getVgap() - întoarce spaţiul liber pe verticală.
44
public void setVgap(int vgap) - setează spaţiul liber pe verticală. public void first(Container parent) - pune deasupra prima componentă din containerul părinte specificat. public void next(Container parent) - pune deasupra următoarea componentă a containerului specificat. public void previous(Container parent) - pune deasupra componenta precedentă a containerului specificat.componenta cu numele name din containerul specificat. public void show(Container parent, String name) - pune deasupra public void last(Container parent) - pune deasupra ultima componentă din containerul specificat.
140. Poziţionarea absolută a componentelor în container În general, este recomandabil ca pentru amplasarea componentelor în containere să se folosească gestionari de poziţionare. În acest fel se asigură modificarea automată a poziţiei şi dimensiunilor componentelor, atunci când se modifică dimensiunile containerului. Există totuşi situaţii, în care se preferă ca poziţiile şi dimensiunile componentelor să fie fixe şi să fie indicate prin program. Din această cauză, în afară de amplasarea flexibilă a componentelor în containere, folosind clasele de gestionare a poziţionării, este posibil să se proiecteze şi interfeţe grafice în care poziţionarea componentelor se face folosind coordonatele şi dimensiunile absolute ale acestora. În acest scop: a/ pentru a se indica faptul că nu se foloseşte un gestionar de poziţionare, se recurge la instrucţiunea: setLayout(null); b/ pentru stabilirea coordonatelor colţului din stânga sus şi dimensiunilor fiecărei componente se foloseşte metoda public void setBounds(int x, int y, int width, int height);
din clasa java.awt.Component. În acest mod, fiecare componentă este plasată în container cu colţul stânga-sus în punctul de coordonate (x,y)şi are dimensiunile date prin lăţimea width şi înălţimea height. În locul metodei setBounds se pot folosi şi metodele public void setLocation(Point location) public void setSize(int latime, int inaltime)
care există, de asemenea, în clasa Component şi permit setarea separată a poziţiei şi dimensiunilor componentelor.
141. Gruparea componentelor Pentru a poziţiona componentele în structuri mai complicate decât cele oferite de clasele de gestionare a poziţiei existente, se poate recurge la gruparea mai multor componente în containere auxiliare, care se plasează apoi în containerul principal. Drept containere auxiliare, se folosesc cel mai frecvent instanţe ale claselor java.awt.Panel, javax.swing.JPanel şi javax.swing.Box.
142. Clasele Panel si JPanel Clasa java.awt.Panel (panou) reprezinta cel mai simplu container, care este o suprafaţă dreptunghiulară fără bordură. Gestionarul de poziţionare implicit este FlowLayout, dar se poate pune oricare altul. Panourile sunt frecvent folosite pentru a plasa pe ele diferite componente, formând un grup care se plaseaza apoi într-un alt container. Clasa javax.swing.JPanel este varianta de Panel folosită în JFC/Swing, fiind un container genreric.
45
143. Clasa Box Clasa javax.swing.Box are ca instanţe containere speciale, care nu pot folosi decât gestionarul de poziţionare javax.swing.BoxLayout. Orice incercare de a-i pune alt gestionar produce o eroare de execuţie din clasa AWTError. Clasa dispune de metode statice pentru crearea de "casete" (instanţe ale clasei Box) orizontale sau verticale: public static Box createHorizontalBox() public static Box createVerticalBox()
Se pot creea, de asemenea "componente invizibile" de dimensiuni fixe sau variabile, care pot fi folosite la distanţarea componentelor vizibile. În acest scop, se folosesc metodele public static Component createRigidArea(Dimension d) - creeaza o "componentă ascunsă" de dimensiune fixă; public static Component createHorizontalStrut(int width) - creeaza o "componentă ascunsă" de lăţime fixă, dar de înălţime variabilă; public static Component createVerticalStrut(int height) - creeaza o "componentă ascunsă" de înalţime fixă, dar de lăţime variabilă; public static Component createGlue() - creaza o "componentă ascunsă" cu ambele dimensiuni variabile;un container din clasa Box, componentele pot fi amplasate numai pe o singură direcţie: orizontală sau verticală.
143. Componentele din JFC/Swing Pentru a realiza interfaţa utilizator grafică a unei aplicaţii folosind JFC/Swing, este necesar ca la fereastra aplicaţiei (din clasa JFrame) să se adauge diferite obiecte grafice numite componente. Deosebim: 1. Componente de control: butoane, butoane radio, casete de validare, liste, liste ascunse, meniuri, rigle ajustabile, câmpuri de text. 2. Componente de afişare needitabile: etichete, indicatoare, etc. 3. Componente de afişare editabile: zone de text, tabele editabile, selectoare de culori, selectoare de fişiere, arbori. 4. Containere: panouri, panouri glisante, etc.
144. Clasa JComponent Clasa abstracta javax.swing.JComponent extinde clasa java.awt.Container. In consecinţă, orice componenta Swing are şi caracteristici de container. Iată, ca exemplu, câteva facilităţi pe care le ofera orice JComponentă: - posibilitatea de a-i ataşa componentei o "inscripţie volanta" (engleză: ToolTip), adică o inscripţie explicativă care apare când punem cursorul de mouse pe componenta respectivă, fără să apăsăm butonul. O astfel de inscripţie se ataşează componentei prin metoda public void setToolTipText(String text); - posibilitatea de a-i pune componentei o bordură, folosind metoda public void setBorder(Border border);
- posibilitatea de a modifica culoarea de fond şi culoarea de primplan ale componentei folosind metodele: public void setBackground(Color color); public void setForeground(Color color);
46
145. Caracteristicile componentelor JFC/Swing Fiecare componentă a interfeţei utilizator grafice se caracterizează prin aspect, stare şi comportament. Aspectul este dat de figura prin care este reprezentată pe ecran componenta respectivă. Fiecare clasă de componente oferă un aspect tipic al instanţelor sale. În JFC/Swing programatorului i se pun însa la dispoziţie metode şi clase prin care poate modifica aspectul componentelor. Starea componentei este dată, ca la orice obiect, de valorile câmpurilor sale. Starea se poate modifica fie datorită acţiunilor utilizatorului, fie datorită invocării prin program a unor metode ale acesteia. În general, la modificarea stării componenta generează un eveniment, iar uneori îşi schimbă şi aspectul. Comportamentul componentei este modul în care aceasta reacţionează atunci cînd se acţionează asupra ei de către utilizator sau când este invocată o metodă şi constă în modificarea stării şi a aspectului şi în generarea de evenimente. Componentele din JFC/Swing oferă programatorului unele facilităţi importante privind stabilirea aspectului şi comportamentului acestora. Iată unele ditre ele: - posibilitatea de a introduce în componentă un text, o imagine, sau ambele; - posibilitatea de a adăuga la fiecare componentă a unui text explicativ volant (engleză: Tool Tip), care conţine indicaţii care apar când se pune cursorul mouse-ului pe componenta respectivă, fără a apăsa butonul de mouse. - posibilitatea de a pune în jurul componentei una sau mai multe borduri (engleză: Border ), cu diferite aspecte: chenar simplu, chenar cu titlu, bordură care dă aspect de supraînălţare, bordură care dă aspect de scufundare; - posibilitatea de a alege aspectul general al tuturor componentelor interfeţei grafice (engleză: Look and Feel ).
146. Componente de control Componentele de control sunt dispozitive de intrare virtuale, uşor de utilizat, prin intermediul cărora utilizatorul poate introduce anumite comenzi. Din această categorie fac parte butoanele, riglele ajustabile, listele, listele ascunse, meniurile şi câmpurile de text.
147. Butoane Butoanele sunt obiecte grafice, al căror aspect este similar celor al butoanelor folosite în aparatura electronică şi electrică. Acţionarea butonului se face punând deasupra lui cursorul mouse-ului şi apasând un buton al acestuia. În JFC/Swing există mai multe tipuri de butoane: butonul simplu, caseta de validare, butonul radio şi articolul de meniu. Toate acestea sunt subclase ale clasei abstracte javax.swing.AbstractButton. 148. Butonul obişnuit (cu o singură stare stabilă) Butoanele obişnuite se realizează folosind clasa javax.swing.JButton, derivată din clasa javax.swing.AbstractButton, aşa cum am arătat în exemplele date în capitolul precedent. Butonul obişnuit are o singură stare stabilă , în care ajunge când este eliberat. Cât timp se ţine butonul de mouse apăsat deasupra lui, butonul se află în starea "apăsat" ("acţionat"). De fiecare dată când este acţionat, butonul generează un AcţionEvent şi un ChangeEvent. Când este eliberat, generează numai un ChangeEvent. Butonul generează de asemenea, ca orice altă componentă, evenimente de componentă, de mouse şi de tastă. Totuşi, în cazul butoanelor obişnuite, cel mai frecvent se folosesc
47
evenimentele de acţiune (ActionEvent), care sunt ascultate de un ascultător de acţiune (ActionListener). Clasele Button şi JButton sunt specificate mai detaliat în Indexul de clase.
149. Butonul cu două stări stabile Clasa javax.swing.JToggleButton este derivata din javax.swing.AbstractButton şi reprezintă butoane cu două stări stabile. Trecerea de la o stare la alta este impusă de utilizator prin click de mouse sau este comandată prin program. În practică, cel mai frecvent se folosesc caseta de validare şi butonul radio, realizate prin subclase ale clasei ToggleButton şi prezentate în continuare. O specificare mai detaliată a clasei JToggleButton este dată în indexul de clase. 150. Caseta de validare Caseta de validare este un obiect de control cu două stări stabile. La fiecare click de mouse pe suprafata casetei de validare, aceasta trece dintr-o stare în cealaltă. În mod obişnuit, caseta de validare este reprezentată grafic printr-un patrat, în care apare un simbol de bifare (de validare), cum ar fi simbolul V sau X, când caseta se găseşte în starea "selectat". În starea opusă (deselectat), caseta este vidă. Imaginea casetei este insoţită şi de un text explicativ. 151. Butonul radio Butonul radio este un buton cu două stări stabile, care face parte dintr-un grup de butoane, astfel că la un moment dat numai unul dintre ele poate fi "selectat". În momentul în care este selectat ("apăsat") un buton al grupului, se deselectează automat cel care era selectat anterior. În JFC/Swing, butoanele radio sunt realizate ca instanţe ale clasei javax.swing.JRadioButton, care este derivată din clasa javax.swing.JToggleButton. Gruparea butoanelor se face folosind clasa javax.swing.ButtonGroup.
152. Liste În cazul interfeţelor utilizator grafice, se numeşte listă o componentă care conţine articole selectabile. Selectarea lor se face de către utilizator, prin click de mouse pe articolul respectiv. Lista poate fi cu selecţie simplă sau cu selecţie multiplă, după cum pot fi selectate simultan unul sau mai multe articole. În JFC/Swing, listele se realizează ca instanţe ale clasei javax.swing.JList. Articolele din listă pot fi, în principiu, orice obiecte afişabile. La crearea listei, constructorului i se dă ca argument tabloul obiectelor pe care le va conţine lista. Ulterior este posibil să se adauge articole la listă, sau să se elimine. Daca lista este mai lunga decât spaţiul de afişare disponibil, ea poate fi pusă pe un panou glisant, din clasa javax.swing.JScrollPane. Punerea articolelor în listă poate fi făcută astfel: - la crearea listei, folosind unul din constructorii public JList(Object[] listData) - primeşte ca argument un tablou de obiecte, care sunt articolele din listă public JList(Vector listData)- primeşte ca argument o instanţă a clasei java.util.Vector, care are ca elemente articolele listei; - în timpul utilizării listei, invocându-se una din metodele public void setListData(Object[] listData) public void setListData(Vector listData)
153.Liste ascunse
48
Lista ascunsă este o listă din care se vede un singur articol (cel care este selectat), deci ocupa pe ecran spaţiu mult mai putin decât una obişnuită. Celelalte articole ale listei sunt "ascunse" şi devin vizibile numai dacă se face click pe articolul vizibil. Dacă acum facem click de mouse pe un alt articol din lista devenită vizibilă, acest nou articol este selectat (rămâne vizibil), iar celelalte dispar. Într-o listă ascunsă nu este posibilă selecţia multiplă. Punerea articolelor în listă se poate face astfel: - la crearea listei ascunse, folosind unul din constructorii public JComboBox(Object[] items) public JComboBox(Vector items)
- în timpul utilizării listei, folosind metodele public void addItem(Object anObject) - adaugă un articol la sfârşitul listei; public void insertItemAt(Object anObject, int index) - înserează un articol pe poziţia index. Eliminarea unui articol din listă se face cu una din metodele public void removeItem(Object anObject) - elimină articolul anObject; public void removeItemAt(int anIndex) - elimină articolul de pe poziţia anIndex.
154. Rigla ajustabilă Clasa javax.swing.JSlider oferă o componentă care are aspectul unei rigle prevăzute cu cursor. Prin deplasarea cursorului cu ajutorul mouse-ului se modifică valoarea indicată de riglă. Valoarea minimă şi cea maximă de pe scala riglei şi valoarea unei diviziuni se indică prin program. Rolul riglei poate fi asemănat cu cel al unui dispozitiv de ajustare continuă, cum este potenţiometrul din aparatura electronică. La deplasarea cursorului, rigla generează evenimente din clasa javax.swing.event.ChangeEvent, care sunt ascultate cu o clasă care implementează interfaţa javax.swing.event.ChangeListener. Crearea riglei se face folosind unul dintre constructorii ei, dintre care cel mai complet este public JSlider(int orientation, int min, int max, int value)
în care orientation - orientarea riglei, care poate fi JSlider.HORIZONTAL sau JSlider.VERTICAL; min, max - valorile minimă şi maximă de pe scala riglei; value - valoarea indicată iniţial de cursorul riglei (trebuie să fie în intervalul [min,max]).
Pentru a stabili aspectul riglei se folosesc metodele public void setMajorTickSpacing(int n) - stabilirea valorii diviziunilor mari public void setMinorTickSpacing(int n) - stabilirea valorii diviziunilor mici public void setPaintTicks(boolean b) - determină dacă diviziunile vor fi vizibile public void setPaintLabels(boolean b) - determină dacă vor fi afişate valorile numerice ale diviziunilor.
155. Meniuri La fel ca listele sau butoanele radio, meniurile permit utilizatorului să aleagă una din mai multe opţiuni posibile. În JFC/Swing se disting două categorii de meniuri: - meniuri cu bară, care pornesc dintr-o bară situată la partea superioară a ferestrei aplicaţiei; - meniuri derulante (pop-up), care apar în poziţia în care se găseşte cursorul de mouse.
156. Meniuri cu bară Bara de meniu se poate plasa, daca este necesara, numai la partea superioara a ferstrei aplicatiei si se realizeaza ca o instanta a clasei javax.swing.JMenuBar.
49
Bara de meniu poate sa conţină unul sau mai multe meniuri, care se realizează ca instanţe ale clasei javax.swing.JMenu. La rândul său, fiecare meniu poate conţine unul sau mai multe articole, care sunt instanţe ale claselor javax.swing.JMenuItem sau javax.swing.JCheckBoxMenuItem. Este însă posibil ca un articol de meniu să fie el însuşi un meniu (din clasa JMenu). Dacă utilizatorul alege cu mouse-ul un aricol de meniu, sunt posibile deci două situaţii: - acesta este un articol propriu-zis (un JMenuItem), în care caz opţiunea respectivă este selectată; - articolul ales este el însuşi un meniu (un JMenu), în care caz noul (sub)meniu se desfăşoară şi căutarea continuă.
157. Meniuri derulante (pop-up) Spre deosebire de meniurile cu bară, meniurile derulante sunt tratate ca nişte componente obişnuite, care pot să fie afişate prin program, atunci când este necesar. În JFC/Swing, meniurile derulante se realizează ca instanţe ale clasei javax.swing.JPopupMenu. În rest, meniul pop-up se comportă la fel ca un meniu cu bară. Afişarea meniului pop-up trebuie programată, folosindu-se în acest scop metoda din clasa JPopupMenu public void show(Component invoker, int x, int y)
în care invoker este referinţa la componenta in spaţiul căreia trebuie să apară meniul, iar x şi y sunt coordonatele punctului în care acesta va fi afişat.
158. Componente de afişare Componentele de afişare sunt cele care servesc pentru a afişa anumite texte sau imagini şi pot fi needitabile sau editabile.
159. Componente de afişare needitabile Componentele de afişare needitabile sunt realizate ca instanţe ale următoarelor clase: - javax.swing.JLabel - pentru realizarea unor "etichete" în care pot fi afişate texte sau imagini, fără a putea fi editate de utilizator; - javax.swing.JTooltip - pentru afişarea de "inscripţii volante", când se pune cursorul de mouse deasupra unei alte componente; - javax.swing.JProgressBar - pentru realizarea unor "bare de progres" adică a unor bare de lungime variabilă, care arată cum evoluează realizarea unei anumite activităţi (de la 0% la 100%).
160. Componente de afişare editabile Componentele de afişare editabile permit utilizatorului operaţii de editare în timpul executării programului. În JFC/Swing există un număr important de clase pentru astfel de componente. Astfel, pentru editare de texte există clasele javax.swing.JTextArea, javax.swing.JTextPane şi javax.swing.JEditorPane. În aceeaşi categorie pot fi încadrate şi clasele javax.swing.JTextField şi javax.swing.JPasswordField, care au fost prezentate anterior. 161. Clasa JTextArea Instanţele clasei javax.swing.JTextArea (arie de text) sunt suprafeţe de afişare a unor texte editabile cu mai multe linii. Componenta are comportamentul unui editor de text simplu: permite să se introducă text de la tastatură, să se şteargă textul în întregime sau pe porţiuni, să se adauge sau să se însereze text. Prin metode speciale se poate seta componenta astfel, încât să se realizeze automat trecerea de la un rând la altul. Se oferă metode prin care se poate adăuga text prin program, sau s e
50
poate obţine sub forma de String textul existent.
162. Utilizarea ferestrelor de dialog Ferestrele de dialog sunt ferestre care se afişează pe ecran numai temporar, pentru a transmite anumite mesaje sau a permite introducerea unor date. Principalul avantaj al folosirii ferestrelor de dialog este că apar pe ecran numai atunci când sunt necesare şi nu încarcă fereastra principală a aplicaţiei cu elemente care nu sunt necesare în permanenţă. În JFC/Swing, ferestrele de dialog se realizează folosind clasa javax.swing.JDialog. Instanţele acestei clase se comportă asemanator cu cele ale clasei JFrame, permiţând adăugarea oricăror componente. La fel ca la JFrame, aceste componente nu se adaugă direct la fereastră, ci la panoul contentPane conţinut în aceasta şi obţinut prin metoda public Container getContentPane(). Fereastra de dialog poate avea ca "proprietar" ( owner ) o instanţă a claselor java.awt.Frame, javax.swing.JFrame, java.awt.Dialog sau javax.swing.JDialog. Proprietarul se transmite ca argument al constructorului ferestrei de dialog. Se permite ca, în loc de proprietar, să se pună argumentul null, în care caz se atribuie un proprietar implicit. Pentru afişarea pe ecran a ferestrei de dialog se invocă metoda public void show(), iar pentru ascunderea ei se invocă metoda public void hide(). În fine, pentru a elimina fereastra de dialog, eliberând toate resursele pe care le foloseşte, se invocă metoda public void dispose(). Aceste trei metode sunt moştenite de JDialog de la superclasa java.awt.Dialog. Când fereastra de dialog este deschisă, ea trece în prim plan sau în plan secund împreună cu proprietarul ei. Ferestrele de dialog pot fi modale sau nemodale. Când este afişată pe ecran o fereastră modală, toate celelalte ferestre existente pe ecran sunt blocate (nu se poate acţiona asupra lor), până când se încheie lucrul cu fereastra de dialog modală respectivă.
163. Clasa Color Clasa Color încapsulează informaţiile despre culoare. În Java AWT se foloseşte modelul de culori RGB (engleză: red, green, blue ) în care fiecare culoare este considerată ca fiind compusă din trei culori fundamentale: roşu, verde şi albastru. În consecinţă, culoarea este dată prin trei numere cuprinse în intervalul [0, 255], reprezentând ponderile celor trei culori fundamentale. În figura de mai jos este reprezentată schema de combinare a acestor trei culori fundamentale. Clasa Color conţine şi un al patrulea câmp, numit alpha, care poate avea, de asemenea, valori întregi în intervalul [0..255] şi exprima opacitatea culorii respective. Daca alpha=255, culoarea este complet opaca. Aceasta înseamnă că, dacă o figură cu această culoare se suprapune peste alta, o m aschează complet. Dacă alpha=0, culoarea este complet transparentă, deci practic invizibilă. Între aceste valori extreme putem avea diferite opacităţi intermediare, cuprinse intre 0 si 255. Culoarea în sistemul RGB poate fi exprimată nu numai printr-o instanţă a clasei Color, ci şi printr-un număr întreg (de tip int), în care cei patru octeţi au, respectiv, valorile componentelor alpha, r, g, b exprimate în intervalul [0..255]. Componentele sunt plasate astfel: alpha în biţii 24..31, r în biţii 16..23, g în biţii 8..15 şi b în biţii 0..7.
51
Clasa Color conţine, de asemenea, constructori şi metode care suportă sistemele de culori sRBG şi HSB. Standardul sRGB defineşte o variantă standardizată a sistemului RGB, destinată monitoarelor cu tub catodic. În acest sistem, parametrii r, g, b şi alpha se exprimă prin numere reale în intervalul [0.0...1.0].
164. Alegerea culorii folosind clasa JColorChooser Pentru a alege culoarea în mod interactiv, în JFC/Swing este prevazută clasa javax.swing.JColorChooser. Instanţele acestei clase sunt panouri de selectare a culorii, care pot fi folosite atât prin încorporarea lor într-o fereastră obişnuită, cât şi sub forma unei ferestre de dialog. Pentru a creea o fereastră de dialog, care conţine în ea un JColorChooser şi întoarce culoarea selectată, în clasa JColorChooser există metoda public static JDialog createDialog(Component c,String title, boolean modal, JColorChooser chooserPane, ActionListener okListener, ActionListener cancelListener)
în care: - c este componenta beneficiară (owner) a ferestrei de dialog create; - title este titlul ferestrei de dialog create; - argumentul boolean modal indică dacă fereastra este modală; - chooserPane este instanţa clasei JColorChooser care se întroduce în fereastra de dialog; - okListener si cancelListener sunt ascultătoarele de acţiune care reacţioneaza la apăsarea butonului OK, respectiv Cancel al selectorului de culoare. Folosind un JColorChooser, alegerea culorii se poate face în trei moduri: - folosind un tablou de culori, în care fiecare celulă este colorată în altă culoare; - în sistemul RGB, folosind trei rigle de ajustare a culorilor fundamentale; - în sistemul HSB, selectând culoarea prin alegerea cu mouse-ul a punctului de pe panou care are culoarea potrivita (trei butoane alăturate, notate H, S, B, arată care din cele trei componente se menţine constantă, celelalte două fiind date de coordonatele punctului ales pe panou).
165. Elemente de grafică Java API ofera programatorilor posibilităţi ample privind realizarea de desene, text stilizat şi alte construcţii grafice. Ne vom rezuma aici numai la câteva noţiuni elementare, utile în realizarea unor aplicaţii grafice simple. In principiu, desenarea se poate face pe orice componentă grafică. Există însă clasa java.awt.Canvas, ale cărei instanţe sunt simple panouri destinate desenării (în engleză Canvas este pânza pictorului). Pentru desenare se mai folosesc frecvent şi clasele JPanel şi JLabel.
Sistemul de coordonate folosit pentru grafică are originea în colţul din stânga sus al componentei, axa Ox este orientată catre dreapta, iar axa Oy este orientată în jos. Coordonatele se exprimă în numere întregi (int), având ca unitate de măsură pixelul (punctul de pe ecran). 166. Contextul grafic Modul de realizare a imaginilor şi desenelor este strâns dependent atât de echipament (hardware) cât şi de sistemul de operare. Pentru a se asigura independenţa de platformă, în Java API a fost introdusă clasa abstractă java.awt.Graphics. Aceasta este clasa de bază a tuturor contextelor grafice, care permit trasarea de desene pe suprafaţa componentelor grafice realizate pe diverse dispozitive fizice.
52
Pe fiecare platformă, în mediul de execuţie Java, trebuie să existe o implementare a contextului grafic, adică o extindere a clasei Graphics, care conţine toate câmpurile şi metodele acestei clase, dar este specifică platformei respective. Un obiect din clasa Graphics încapsulează informaţia de stare a contextului grafic la care se referă şi anume: - referinţa la obiectul din clasa Component (sau dintr-o subclasa a acesteia) pe care se desenează; - o translaţie a originii sistemului de coordonate; toate coordonatele din desen sunt raportate la această origine; - decupajul curent (dreptunghiul în interiorul căruia se trasează desenul); - culoarea curentă; - fontul curent; - operaţia logică pe pixeli curentă (XOR sau paint); - alternarea curentă de culori pentru operaţia pe pixeli XOR
167. Fluxuri de intrare/ieşire şi fişiere Fluxul este un concept situat pe un nivel înalt de abstractizare, fiind privit ca
o simplă succesiune de octeţi sau de caractere care se transmite între sursă şi destinaţie. Nu prezintă importanţă nici natura sursei sau a destinaţiei, nici modul în care trebuie interpretată secvenţa de octeti sau de caractere respectivă. De exemplu, un grup de 32 de octeţi transmişi între sursă şi destinaţie poate să reprezinte 32 de caractere ASCII sau 16 caractere Unicode sau 8 numere de tip int sau 4 numere de tip double etc. Această abstractizare permite să se trateze în mod unitar toate tipurile de transmisii de date.
Se disting doua feluri de fluxuri: de ieşire şi de intrare. Pentru un proces dat, toate fluxurile transmise de acesta către exterior se numesc fluxuri de ieşire, iar cele primite din exterior se numesc fluxuri de intrare. În consecinţă, acelaşi flux este de ieşire în raport cu sursa şi de intrare în raport cu destinaţia. Principalele operaţii care au loc asupra unui flux sunt:
La sursă (flux de ieşire) - Deschiderea fluxului - cât timp (există date de transmis) scriere în flux -Închiderea fluxului
La destinaţie (flux de intrare) -Deschiderea fluxului - cât timp (există date de citit) citire din flux -Închiderea fluxului
Programatorului procesului sursă îi revine obligaţia de a pregăti, sub forma unei succesiuni de caractere sau de octeţi, datele care urmează a fi transmise pe fluxul de ieşire. Interpretarea şi tratarea datelor conţinute în flux se face de către procesul de destinaţie, deci întreaga responsabilitate îi revine celui care programează acest proces. Desigur că este necesar ca interpretarea datelor din flux la destinaţie să corespundă cu cea de la sursă. Programarea operaţiilor de intrare/ieşire poate fi destul de complicată, dar în limbajul Java ea este totuşi uşurată de existenţa unui număr destul de mare de clase cu această destinaţie, grupate în pachetul java.io.
168. Pachetul java.io În Java 2 SDK se consideră că fluxurile pot fi de caractere sau de octeţi. În primul caz, de la sursă la destinaţie se transmite o succesiune de caractere Unicode (de câte 16 biţi), iar în al doilea caz - o succesiune de octeţi (de 8 biţi). În mod corespunzător, pentru fiecare din cele două categorii de fluxuri există câte o ierarhie de clase de fluxuri de intrare şi o ierarhie de clase de fluxuri de iesire. Pentru fluxurile de caractere, rădăcinile ierarhiilor de clase sunt clasele abstracte Reader şi Writer .Pentru fluxurile de octeţi, rădăcinile acestor ierarhii sunt clasele abstracte InputStream şi OutputStream.
53
Aceste ierarhii de clase sunt reprezentate în figurile 2, 3, 4 şi 5. În afară de cele patru ierarhii menţionate, în pachetul java.io există şi clase auxiliare şi interfete. Distingem trei tipuri de clase, care sunt reprezentate în aceste figuri prin culori diferite: - clase abstracte (culoare albastră); - clase care efectuează operaţiile de intrare sau de ieşire propriu-zise (culoare verde) şi modelează sursele sau destinaţiile fluxurilor (engleză: Data Sink Streams); - clase care efectuează unele operaţii de transformare a datelor de pe flux (culoare violet) şi reprezinta "fluxuri de prelucrare" (engleză: Processing Streams).
169. Clasa Reader Clasa abstractă java.io.Reader este rădăcina ierarhiei de clase de fluxuri de intrare de caractere. Metode: public int read() throws IOException - citeşte din fluxul de intrare un singur caracter; întoarce caracterul citit (în domeniul 0 .. 16383) sau -1 dacă s-a ajuns la sfârşit de fişier; metoda produce blocarea procesului în care este invocată, până când apare un caracter în fluxul de intrare; public int read(char[] cbuf) throws IOException - citeşte din flux o secvenţă de caractere şi le depune într-o zonă tampon (buffer) constituită din tabloul de caractere cbuf; întoarce numărul de caractere citite sau -1 dacă s-a atins sfârşitul de fişier; metoda produce blocarea procesului până când apar caractere în fluxul de intrare, sau se ajunge la sfârşit de fişier; public abstract int read(char[] cbuf, int off, int len) throws IOException - acţionează asemănător cu metoda precedentă, dar depunerea caracterelor citite în zona tampon de destinaţie se face începând de la poziţia off (offset), iar numărul maxim de caractere citite este len; public long skip(long n) throws IOException - se sare peste n caractere din fluxul de intrare, care nu vor fi citite; procesul apelant este blocat pană când apare cel puţin un caracter în fluxul de intrare; dacă se întâlneşte sfârşitul de fişier, se generează o excepţie de intrare/ieşire; întoarce numărul de caractere sărite efectiv; public boolean ready() - întoarce true dacă fluxul de intrare este gata pentru a putea fi citit; public void mark(int readAheadLimit) throws IOException - marchează poziţia curentă în fluxul de intrare, pentru a se putea reveni la ea ulterior; argumentul readAheadLimit indică numărul de caractere care vor putea fi ulterior citite din flux,fără ca acest marcaj să se piardă; excepţia de intrare/ieşire apare dacă fluxul nu suportă marcarea sau dacă se produce altă eroare de intrare/ieşire; public boolean markSupported() - indică dacă fluxul suportă marcarea; public void reset() throws IOException - dacă fluxul a fost marcat, este readus la poziţia corespunzătoare ultimului marcaj; dacă fluxul nu a fost marcat sau nu suportă resetarea, se generează o excepţie de intrare/ieşire; public abstract void close() throws IOException - închide fluxul; din acest moment, invocarea metodelor read(), ready(), mark() sau reset pentru acest flux va genera o excepţie de intrare/ieşire.
170. Clasa Writer Clasa abstractă java.io.Writer este rădăcina ierarhiei de clase pentru fluxuri de ieşire de caractere. Metode: public void write(int c) throws IOException - scrie în fluxul de ieşire caracterul c; public void write(char[] cbuf) throws IOException - scrie în fluxul de ieşire caracterele conţinute în tabloul cbuf ; public abstract void(char[] cbuf, int off, int len) throws IOException - scrie în fluxul de ieşire len caractere din tabloul cbuf , începând de la poziţia off (offset); public void write(String str) throws IOException - scrie în flux caracterele existente în şirul str ; public void write(String str, int off, int len) throws IOException - scrie în flux len caractere din şirul str , începând de la poziţia off (offset);
54
public abstract void flush() throws IOException - "descarcă" fluxul de ieşire; dacă fluxul a salvat într-o
zonă tampon anumite caractere scrise cu metodele write(), aceste caractere sunt scrise efectiv în fluxul de destinaţie; dacă această destinaţie este tot un flux, invocă şi metoda flush() a acestuia, astfel că se "descarcă" întregul lanţ de fluxuri; public abstract void close() throws IOException - se închide fluxul de ieşire; invocarea ulterioară a metodelor write() sau flush() pentru acest flux va produce o excepţie de intrare/ieşire.
171. Clasa InputStream Clasa java.io.InputStream este rădăcina ierarhiei de clase pentru fluxuri de intrare organizate pe octeţi. Metode: public int read() throws IOException - citeşte din fluxul de intrare un singur octet; întoarce octetul citit (in domeniul 0 .. 255) sau -1 dacă s-a ajuns la sfârşit de fişier; metoda produce blocarea procesului în care este invocată, până când apare un octet în fluxul de intrare; public int read(byte[] buf) throws IOException - citeşte din flux o secvenţă de octeţi şi îi depune într-o zonă tampon (buffer) constituită din tabloul de octeţi buf ; întoarce numărul de octeţi citiţi sau -1 dacă s-a atins sfârşitul de fişier; metoda produce blocarea procesului până când apar octeţi în fluxul de intrare, sau se ajunge la sfârşit de fişier; public abstract int read(byte[] buf, int off, int len) throws IOException - acţionează asemănător cu metoda precedentă, dar depunerea octeţilor citiţi în tabloul de destinaţie byte[] se face începând de la poziţia off (offset), iar numărul maxim de octeţi citiţi este len; public long skip(long n) throws IOException - se sare peste n octeţi din fluxul de intrare, care nu vor fi citiţi; procesul apelant este blocat până când apare cel puţin un octet în fluxul de intrare; dacă se întâlneşte sfârşitul de fişier se generează o eroare de intrare/ieşire; întoarce numărul de octeţi săriţi efectiv; public int available() throws IOException - întoarce numărul de octeţi disponibili pentru citire în fluxul de intrare; public void mark(int readAheadLimit) throws IOException - marchează poziţia curenta în fluxul de intrare, pentru a se putea reveni la ea ulterior; argumentul readAheadLimit indică numărul de octeţi care vor putea fi ulterior citiţi din flux, fără ca acest marcaj să se piardă; excepţia de intrare/ieşire apare dacă fluxul nu suportă marcarea sau dacă se produce altă eroare de intrare/ieşire; public boolean markSupported() - indică dacă fluxul suportă marcarea; public void reset() throws IOException - dacă fluxul a fost marcat, este readus la poziţia corespunzătoare ultimului marcaj; dacă fluxul nu a fost marcat sau nu suporta resetarea, se generează o excepţie de intrare/ieşire; public abstract void close() throws IOException - închide fluxul; din acest moment, invocarea metodelor read(), ready(), mark() sau reset() pentru acest flux va genera o excepţie de intrare/ieşire.
171. Clasa OutputStream Clasa java.io.OutputStream este rădăcina ierarhiei de clase pentru fluxuri de iesire de octeţi. Metode: public void write(int c) throws IOException - scrie în fluxul de ieşire ultimul octet al numărului c; public void write(byte[] buf) throws IOException - scrie în fluxul de ieşire octeţii conţinuti în tabloul buf ; public abstract void(byte[] buf, int off, int len) throws IOException - scrie în fluxul de ieşire len octeţi din tabloul buf , începând de la poziţia off (offset); public abstract void flush() throws IOException - "descarcă" fluxul de ieşire; dacă fluxul a salvat într-o zonă tampon anumiţi octeţi scrişi cu metodele write(), aceşti octeţi sunt scrişi efectiv în fluxul de destinaţie; dacă această destinaţie este tot un flux, invocă şi metoda flush() a acestuia, astfel că se "descarcă" întregul lanţ de fluxuri;
55
public abstract void close() throws IOException - se închide fluxul de ieşire; invocarea ulterioară a
metodelor write() sau flush() pentru acest flux va produce o excepţie de intrare/ieşire.
172. Clasele PrintStream şi PrintWriter Clasele java.io.PrintStream şi java.io.PrintWriter se folosesc pentru a transmite către un flux se ieşire date formatate pentru tipărire (afişare). Se ştie că forma internă a datelor diferă de forma externă. De exemplu, numerele întregi sunt reprezentate intern sub formă binară, în timp ce pe ecranul calculatorului sau la imprimantă apar sub forma unor şiruri de cifre zecimale, precedate eventual de semn. Metodele claselor PrintStream şi PrintWriter fac această conversie din forma internă în cea externă a diferitelor tipuri de date, generând reprezentările datelor respective sub forma de şiruri de octeţi (caractere în codul ASCII) sau, respectiv, de caractere Unicode. Aceste clase nu se folosesc în mod independent, ci adaugă altui flux de ieşire (de octeţi sau, respectiv, de caractere) capacitatea de formatare a datelor în vederea tipăririi. 173. Fluxuri de prelucrare Fluxurile de prelucrare se conectează la alte fluxuri de intrare/ieşire pentru a face anumite transformări asupra datelor din fluxul respectiv. Clasele de fluxuri de prelucrare din Java API au fost prezentate pe scurt la descrierea pachetului java.io. În această secţiune ne vom ocupa de două categorii de fluxuri de prelucrare: fluxurile de date şi fluxurile de obiecte.
174. Fluxuri de date În unele aplicaţii se doreşte să se transmită într-un flux de ieşire sau să se recepţioneze dintr-un flux de intrare date primitive reprezentate binar (de tip boolean, char, byte, short, int, long, float sau double) şi şiruri de caractere. În acest scop, pot fi folosite clasele java.io.DataOutputStream şi java.io.DataInputStream. Se pot citi cu un DataInputStream numai date care au fost scrise cu un DataOutputStream. 175. Clasa DataOutputStream Clasa java.io.DataOutputStream este derivată din clasa java.io.FilterOutputStream şi implementează interfaţa java.io.DataOutput. Ea permite să se transmită date primitive către un flux de ieşire într-o formă portabilă (independentă de platformă), cu condiţia ca aceste date să fie citite ulterior printr-un DataInputStream. Constructor: public DataOutputStream(OutputStream out) - creează un nou flux de ieşire de date, conectat la ieşire la un OutputStream (adică la o instanţă a unei clase derivate din clasa OutputStream). Metode: Aceasta clasă conţine metodele clasei java.io.OutputStream, la care se adaugă următoarele metode specifice, destinate scrierii în fluxul de ieşire a datelor primitive sau a unor şiruri de caractere: public final void writeBoolean(boolean v) throws IOException - scrie o valoare booleană; public final void writeChar(char v) throws IOException - scrie o valoare de tip char, în format Unicode; public final void writeByte(byte v) throws IOException - scrie o valoare de tip byte pe un octet; public final void writeShort(short v) throws IOException - scrie o valoare de tip short pe doi octeţi; public final void writeInt(int v) throws IOException - scrie o valoare de tip int pe 4 octeţi; public final void writeLong(long v) throws IOException - scrie o valoare de tip long pe 8 octeţi; public final void writeFloat(float v) throws IOException - scrie o valoare de tip float pe 4 octeţi; public final void writeDouble(double v) throws IOException - scrie o valoare de tip double pe opt octeţi; public final void writeBytes(String v) throws IOException - scrie un şir de caractere, convertit într-un şir
de octeţi prin suprimarea octetului superior al fiecărui caracter; public final void writeChars(String v) throws IOException - scrie în flux un şir de caractere (în
56
Unicode); public final void writeUTF(String v) throws IOException - scrie un şir de caractere codificat în formatul
UTF-8 într-o formă independentă de maşină (se scrie mai întâi lungimea şirului pe doi octeţi, apoi fiecare caracter din şir pe câte un singur octet); public final int size() - întoarce numărul de octeţi scrişi în acest flux de ieşire.
176. Clasa DataInputStream Un DataInputStream este un flux de intrare de octeţi care este conectat la intrare la un alt InputStream şi citeste din acesta date primitive într-o formă independentă de platformă. Se pot citi cu DataInputStream numai date care au fost scrise cu DataOutputStream. Constructor: public DataInputStream(InputStream in) - creează un flux de date de intrare, care citeşte date din fluxul de intrare in, primit ca argument.
Metode: Aceasta clasă conţine toate metodele clasei java.io.InputStream, la care se adaugă următoarele metode specifice, prin care se implementează interfaţa java.io.DataInput: public final void readFully(byte[] b) throws IOException - citeşte din fluxul de intrare un număr de octeţi egal cu lungimea tabloului b, primit ca argument, şi îi pune în acest tablou. Dacă în fluxul de intrare nu sunt înca suficienţi octeţi, dar nu s-a atins sfârşitul de fişier, procesul este pus în aşteptare până apar noi octeţi. Dacă se întâlneşte sfârşitul de fişier (EOF - End of File), se generează o EOFException; public final void readFully(byte[] b, int off, int len) throws IOException - acţionează similar cu metoda precedentă, dar se citesc len octeţi, care sunt depuşi în tabloul b, începand de la poziţia off; public final void skipBytes(int n) throws IOException - sare peste n octeţi din fluxul de intrare; întoarce numărul de octeţi săriţi efectiv (este posibil să nu reuşească să sară n octeti, de exemplu dacă a întalnit sfârşitul fluxului); public final boolean readBoolean() throws IOException - citeşte un octet din fluxul de intrare şi îl converteşte în valoare booleană; public final byte readByte() throws IOException - citeşte din fluxul de intrare un singur octet, pe care îl tratează ca un număr întreg cu semn în intervalul [-128, 127]; se consideră că a fost scris cu writeByte(byte v); public final int readUnsignedByte() throws IOException - citeşte din fluxul de intrare un singur octet, pe care îl tratează ca număr întreg fără semn în intervalul [0, 255] şi îl întoarce sub formă de int; public final short readShort() throws IOException - citeşte doi octeţi din fluxul de intrare şi îi interpretează ca un număr de tip short, scris anterior cu writeShort(short v); public final int readUnsignedShort() throws IOException - citeşte din fluxul de intrare doi octeţi, pe care îi interpretează ca număr întreg fără semn şi-l întoarce sub formă de int; public final char readChar() throws IOException - citeşte din fluxul de intrare un char (doi octeţi, format Unicode); public final int readInt() throws IOException - citeşte patru octeţi si îi interpretează ca un număr de tip int scris cu writeInt(int v); public final long readLong() throws IOException - citeste opt octeţi si îi interpretează ca un număr de tip long, scris cu writeLong(long v); public final float readFloat() throws IOException - citeşte patru octeţi si îi interpretează ca un număr de tip float, scris cu writeFloat(float v); public final double readDouble() throws IOException - citeşte opt octeţi si îi interpretează ca un număr de tip double, scris cu writeDouble(double v); public final String readUTF() throws IOException - citeşte un şir de caractere în format UTF (care a fost scris cu writeUTF(String str));
57
177. Fluxuri de obiecte Fluxurile de obiecte sunt fluxuri de prelucrare care permit să se transmită obiecte. În acest s cop, obiectele transmise trebuie să fie serializate, înainte de a fi transmise, adică să fie puse sub forma unei serii de octeti, într-un format care să permită la destinaţie reconstituirea în memorie a obiectului respectiv. Astfel de obiecte se numesc serializabile. Pe platforma Java 2, fluxurile de obiecte se realizează prin clasele java.io.ObjectOutputStream şi java.io.ObjectInputStream. Obiectele transmise de aceste fluxuri trebuie sa implementeze interfaţa java.io.Serializable.
178. Interfaţa Serializable Orice obiect care se transmite pe un flux trebuie să aparţină unei clase care implementează interfaţa java.io.Serializable. Aceasta inseamnă că trebuie îndeplinite următoarele condiţii: - la declararea clasei respective, se pune clauza implements Serializable; - clasa trebuie să conţină un constructor fără argumente; - toate câmpurile obiectului trebuie să fie serializabile, adică fie să aparţina unor tipuri de date, primitive, fie unor clase care implementează interfaţa Serializable. Interfaţa Serializable nu conţine câmpuri sau metode. Clauza implements Serializable constituie doar o indicaţie pentru compilatorul Java să o pună sub forma serializabilă.
179. Clasa ObjectOutputStream Clasa java.io.ObjectOutputStream este clasa fluxurilor de prelucrare pentru obiecte, având rolul de a serializa obiectele care urmează să fie puse într-un flux de ieşire. Fluxurile de obiecte se conectează la ieşire la un alt flux, de preferinţă la un FileOutputStream, ByteArrayOutputStream sau PipedOutputStream, iar utilizarea lor este asemănătoare cu cea a fluxurilor de date (DataOutputStream). Într-un flux de obiecte se pot scrie atât obiecte serializate, cât şi date primitive sau şiruri. Clasa ObjectOutputStream conţine toate metodele de scriere a datelor primitive şi a şirurilor, care există şi în clasele DataOutputStream şi RandomAccessFile. În plus, ea conţine metode necesare pentru scrierea în flux a obiectelor, cea mai frecvent folosită fiind următoarea: public final void writeObject(Object obj)throws IOException - scrie în fluxul de ieşire obiectul obj sub formă serializată; Informaţii mult mai ample despre această clasă pot fi găsite în documentaţia Java API. 180. Clasa ObjectInputStream Clasa java.io.ObjectInputStream serveşte pentru citirea (deserializarea) fluxurilor de obiecte care au fost scrise folosind clasa java.io.ObjectOutputStream. Intrarea unui ObjectInputStream este conectată la ieşirea unui alt flux de intrare, de preferinţă FileInputStream, ByteArrayInputStream sau PipedInputStream. Clasa ObjectInputStream conţine toate metodele de citire a datelor primitive şi a şirurilor existente î n clasa DataInputStream. În plus, ea conţine metode necesare pentru citirea obiectelor serializate, dintre care cea mai frecvent folosită este public final Object readObject() throws OptionalDataException, ClassNotFoundException, IOException
Informaţii mai ample despre această clasă se găsesc în documentaţia Java API.
181.
58
Fişiere În memoria externă a calculatorului, datele se păstrează sub forma de fişiere. Fişierul (engleză: File) este o colecţie de înregistrări situată, de regulă, pe un suport extern şi identificată printr-un nume. Fiecare înregistrare (engleză: Record ) este o grupare de informaţii sau de date care poate fi tratată în mod unitar. Fişierele pot fi clasificate după diferite criterii. După formatul înregistrărilor , distingem fişiere de text şi fişiere de date. În fişierele de text , fiecare înregistrare este o linie de text , adică un şir de caractere care se termină
cu un marcaj de trecere la linie nouă. Acest marcaj depinde de platformă. De exemplu, în fişierele MS-DOS marcajul de sfârşit de linie este format din secvenţa de caractere "\r\n", adică din caracterul de întoarcere la cap de linie (Carriage Return, '\r' ) şi caracterul de linie nouă (New Line, '\n'), care au codurile ASCII 0x0D şi respectiv 0x0A. Pe platforme Unix, marcajul de sfârşit de linie es te constituit numai din caracterul '\n' (New Line, 0x0A). Liniile textului pot avea lungimi diferite. Codificarea caracterelor în fişier depinde, de asemenea, de platformă. În prezent, pentru fişierele de text se foloseşte cel mai frecvent codul ASCII, dar pot exista şi platforme pe care se foloseşte Unicode sau o altă convenţie de codificare. În fişierele de date, înregistrările au, de regulă, lungime predefinită, iar fiecare înregistrare este constituită din mai multe câmpuri de date . În principiu, toate înregistrările unui fişier de date au acelaşi format . Prin formatul înregistrării se înţelege descrierea structurii acesteia, care constă din specificarea câmpurilor de date pe care le conţine, a lungimii fiecărui câmp, a tipului de date conţinut în fiecare câmp şi a modului de reprezentare a datelor. Datele din câmpuri pot fi reprezentate fie sub forma lor externă, fie sub formă binară, iar formatul înregistrărilor diferă de la un fişier la altul. După modul de exploatare, fişierele pot fi de intrare, de ieşire sau de intrare/ieşire (de manevră) . În cazul fişierelor de intrare, din momentul deschiderii fişierului şi până în momentul închiderii acestuia se pot efectua numai operaţii de citire. În cazul fişierelor de ieşire, între momentele de deschidere şi
de închidere a fişierului respectiv se pot face numai operaţii de scrieire. Desigur însă că, după ce s-a încheiat scrierea într-un anumit fişier de ieşire şi acesta a fost închis, el poate fi deschis ca fişier de intrare. Acelaşi fişier poate fi citit de mai multe ori. Fişierele de intrare/ieşire permit ca, după ce au fost deschise, să se efectueze atât operaţii de scriere, cât şi de citire. După modul de acces fişierele pot fi cu acces secvenţial sau cu acces direct . Fişierele cu acces secvenţial se caracterizează prin faptul că înregistrările lor pot fi parcurse într-un singur sens, în ordinea în care acestea sunt plasate în fişier. În cazul fişierelor cu acces direct , numite şi fişiere cu acces aleator (engleză: random access file ) ordinea de parcurgere a înregistrărilor din fişier este
arbitrară, în sensul că la fiecare operaţie de intrare/ieşire făcută asupra fisierului respectiv se poate indica adresa sau numărul de ordine al înregistrării care va fi citită sau scrisă.
182. Clasa File Instanţele clasei java.io.File conţin informaţii privind numele fişierului şi calea pe care se găseste acesta (engleza: Path). Clasa File oferă, de asemenea, metode prin care se pot face unele operaţii legate de prezenţa fişierului respectiv: se poate afla dacă fişierul există, dacă el poate fi citit sau scris, se poate crea un fişier nou, se poate şterge un fişier existent etc. Calea indică modul în care poate fi localizat fişierul de pe disc. Calea poate fi absolută sau relativă. Calea absolută constă în indicarea unităţii de disc şi a succesiunii de directoare prin care se ajunge de la rădacină la fişierul care ne interesează. Calea relativă, arată cum se poate ajunge de la directorul curent la fişierul căutat. Se ştie că, pe diferite platforme, calea se reprezintă în moduri diferite. De exemplu, în sistemul Unix, calea relativa "../../alpha/beta/fisier1.txt" indică faptul că, pornind de la directorul curent , se face o deplasare către rădăcină cu doua directoare, după care se merge înainte (către frunzele arborelui
59
director) trecând la subdirectorul alpha şi de aici la subdirectorul beta, în care se găseşte fişierul căutat cu numele fişier1.txt . Remarcăm că separarea directoarelor se face prin caracterul '/' (slash). Pe platformele firmei Microsoft (MS-DOS, Windows), ca separator se foloseşte caracterul '\' (backslash), care în limbajele C şi Java se reprezintă sub forma '\\'. În consecinţă, aceeaşi cale relativă se va scrie pe o astfel de platforma sub forma "..\\..\\alpha\\beta\\fisier1.txt". În clasa File, reprezentarea căii se face sub o formă independentă de platformă. În acest scop, în instanţele clasei File, calea se păstrează sub forma unui tablou de şiruri de caractere, în care se memoreaza numele fiecărui director conţinut în cale. Separatorul se păstrează într-un câmp separat şi este setat automat în funcţie de sistemul de operare al calculatorului pe care se execută programul. În acest fel, portabilitatea programului creşte, întrucât nu trebuie modificate căile fişierelor folosite în program atunci când se trece de pe o platformă pe alta
183. Citirea fluxurilor de octeţi: clasa FileInputStream Clasa java.io.FileInputStream permite citirea datelor din fişiere sub forma de fluxuri de octeţi. Orice instanţă a acestei clase este un flux de intrare, care are ca sursă un fişier. La crearea acestei instanţe se caută şi se deschide fişierul indicat ca argument al constructorului. Dacă fişierul nu există, sau nu poate fi deschis pentru citire, se generează o excepţie. 184. Citirea din fişiere de caractere: Clasa FileReader Citirea unui fişier de text se poate face nu numai folosind o instanţă a clasei FileInputStream, ci şi o instanţă a clasei FileReader. Deosebirea este că această ultimă clasă creează un flux de caractere, în loc de un flux de octeţi. Chiar dacă fişierul nu este codificat în Unicode, ci în alt cod de caractere (de cele mai multe ori ASCII), se face automat conversia în Unicode. Clasa java.io.FileReader este derivată din clasa java.io.InputStreamReader şi foloseşte metodele acesteia Constructori: public FileReader(String fileName) throws FileNotFoundException - deschide ca flux de caractere de intrare fişierul cu numele fileName (eventual acest şir cuprinde şi calea); public FileReader(File file) - throws FileNotFoundException - deschide ca flux de intrare de caractere fişierul cu calea file; public FileReader(FileDescriptor fd) - deschide un nou flux de intrare de caractere şi îl conectează la fluxul deja existent, al cărui descriptor este fd . Metode: Clasa FileReader nu are metode proprii, dar moşteneşte următoarele metode ale clasei InputStreamReader: public int read() throws IOException - citeşte din fluxul de intrare un singur caracter şi-l întoarce convertit în int; public int read(char[] buf, int off, int len) throws IOException - citeşte din fluxul de intrare cel mult len caractere, pe care le pune în tabloul buf începând de la poziţia off (offset); public boolean ready() throws IOException - verifică dacă fluxul de intrare este gata pentru citire (dacă conţine caractere care pot fi citite); public void close() throws IOException - închide fluxul de intrare; public String getEncoding() - întoarce numele canonic al codului folosit pentru caractere.
185. Clasa FileWriter Scrierea într-un fişier de text se poate face, de asemenea, folosind clasa FileWriter. Instanţele acestei clase sunt fluxuri de ieşire de caractere, prin care se face scrierea într-un fişier. Clasa FileWriter este derivată din java.io.OutputStreamWriter şi foloseşte metodele acesteia. Constructori:
60
public FileWriter(String fileName) throws IOException - deschide fişierul fileName pentru scriere şi
creează un flux de caractere de ieşire conectat la acest fişier; dacă fişi erul nu există, îl creează; public FileWriter(String fileName, boolean append) throws IOException - la fel ca în cazul constructorului precedent, dar, dacă al doilea parametru este true, scrierea în fişier se va face în coada celui deja existent; public FileWriter(File file) throws IOException - deschide pentru scriere fişierul indicat prin calea file şi creează un flux de caractere de ieşire conectat la acest fişier; public FileWriter(FileDescriptor fd) - creează un flux de caractere de ieşire şi îl conectează la fluxul deja existent, cu descriptorul fd ;
Metode: Metodele clasei FileWriter sunt moştenite de la clasa OutputStreamWriter. public void write(int c) throws IOException - scrie în fişier un singur caracter; public void write(char[] cbuf, int off, int len) throws IOException - scrie în fişierul de ieşire len caractere din tabloul de caractere cbuf , începând de la poziţia off (offset); public void write(String str, int off, int len) throws IOException - scrie în fişier len caractere din şirul str începând de la poziţia off ; public void flush() throws IOException - goleşte conţinutul zonei tampon, descărcându-l în fişierul de ieşire; public void close() throws IOException - închide fişierul de ieşire; public String getEncoding() - întoarce numele canonic al codului de caractere utilizat de acest flux.
186. Fişiere cu acces direct Fişierele cu acces direct, numite şi fisiere cu acces aleator (engl.: Random Access File), sunt fişiere la care programatorul poate indica prin program locul (adresa) din fişier de la care începe operaţia de citire sau de scriere. De regulă, astfel de fişiere pot fi utilizate atât pentru citire, cât şi pentru scriere. Pentru ca înregistrările sale să poată fi parcurse într-o ordine arbitrară, fişierul cu acces direct trebuie să fie stocat pe un suport adresabil, cum ar fi discul magnetic, discul optic, memoria RAM sau ROM. În JDK, fişierele cu acces direct sunt instanţe ale clasei RandomAccessFile.
187. Clasa RandomAccessFile Clasa java.io.RandomAccessFile este derivată direct din clasa Object, deci nu face parte din niciuna din cele patru ierarhii de fluxuri de intrare/ieşire prezentate anterior, deşi face parte, ca şi acestea, din pachetul java.io. Fişierul cu acces direct este privit aici ca un tablou de octeţi memorat într-un sistem de fişiere (de regulă în memoria externă). Există un cursor al fişierului (numit în engleză File Pointer ), care se comportă ca un indice al acestui tablou. Valoarea acestui indice (poziţia cursorului de fişier relativ la începutul acestuia) poate fi "citită" cu metoda getFilePointer() şi poate fi modificată cu metoda seek(). Orice citire sau scriere se face începând de la poziţia pe care se găseşte acest cursor. La sfârşitul operaţiei, cursorul se deplasează pe o distanţă corespunzatoare cu numarul de octeţi care au fost citiţi sau scrişi efectiv. Fişierul cu acces direct poate fi deschis în modul read (numai pentru citire), write (numai pentru scriere) sau read/write. În ultimul caz, este posibil să se efectueze atât citiri , cât şi scrieri.
188. Conceptul de proces. Procese paralele şi concurente
61
În general, se numeşte proces o succesiune de transformări sau de operaţii care conduce la realizarea unui anumit rezultat. Esenţial pentru un proces este caracterul său temporal : fiecare transformare elementară necesită un anumit timp, iar procesul în ansamblu este o succesiune de astfel de transformări elementare. Termenul este folosit în domenii diferite: procese fizice, procese chimice, procese tehnologice, procese biologice, procese economice, procese sociale, procese juridice etc În informatică, procesul este un program în execuţie. În consecinţă, fiecărui proces i se asociază un program, şi un ansamblu de resurse necesare executării acestui program: o anumită zonă din memoria internă în care se păstrează datele programului, acces la procesorul sistemului, acces la anumite dispozitive de intrare/ieşire etc. Procesul constă tocmai în efectuarea în timp a succesiunii de operaţii prevăzută în program, folosind în acest scop resursele alocate. În mod tradiţional, programul este executat de către un singur procesor (dispozitiv de prelucrare), care poate efectua, la un moment de timp dat, numai o singură operaţie. În consecinţă, operaţiile prevăzute în program trebuie executate secvenţial , astfel încât operaţia următoare nu poate începe decât după încheierea celei precedente. Toate programele prezentate de noi în capitolele precedente se încadrează în această categorie. Majoritatea sistemelor de operare ale calculatoarelor moderne permit executarea în acelaşi timp a mai multor programe, deci permit concurenţa proceselor la nivel de program (de aplicaţie). De exemplu, în timp ce edităm un text, putem tipări alt text la imprimantă, putem aştepta sosirea de pe reţea a unei pagini de Web etc. Studierea acestui mod de funcţionare a calculatorului, cunoscut sub numele de multitasking , se face la cursul de "Sisteme de operare". Pentru a pune în evidenţă distincţia între program şi proces, putem menţiona că acelaşi program poate da naştere la procese diferite: dacă programul conţine ramificaţii şi/sau cicluri, parcurgerea efectivă a acestora (ce ramuri vor fi executate efectiv şi de câte ori se vor parcurge ciclurile) depinde de datele de intrare. În cadrul multitaskingului, este chiar posibil ca doi utilizatori să utilizeze simultan acelaşi program folosind date diferite, astfel încât se generează procese diferite.
189. Fire de execuţie Firul de execuţie (în engleză: Thread ) este, în esenţă, un subproces strict secvenţial. Menţinând definiţia procesului ca un program în curs de execuţie, putem considera acum că procesul este format din mai multe fire de execuţie care se derulează în paralel, concurând la utilizarea resurselor alocate procesului respectiv. În limbajul Java, există posibilitatea de a se crea programe care conţin mai multe fire de execuţie. Aceasta înseamnă că, la executarea lor, se vor crea mai multe subprocese care se vor desfăşura simultan, folosind acelaşi procesor şi aceeaşi zonă de memorie. Acest mod de funcţionare se numeşte în engleză multithreading . Există două moduri de a programa un fir de execuţie: - prin extinderea clasei Thread; - prin implementarea interfeţei Runnable .
62
190. Clasa Thread Clasa java.lang.Thread realizează un fir de execuţie. Acesta poate fi un fir de execuţie obişnuit, sau un demon. Crearea unui fir de execuţie se face invocând unul dintre constructorii clasei Thread. Dintre aceştia, îi menţionâm aici pe următorii: public Thread() - creează un nou fir de execuţie cu numele implicit Thread- n, unde n este un număr de ordine; public Thread(String name) - creează un nou fir de execuţie cu numele name; public Thread(Runnable target) - creează un nou fir de execuţie, care conţine obiectul target cu interfaţa Runnable , iar numele firului este cel implicit; public Thread(Runnable target, String name) - creează un nou fir de execuţie, care conţine obiectul target cu interfaţa Runnable şi are numele name. La programarea unui fir de execuţie, principala atenţie se acordă metodei run(), deoarece ea conţine programul propriu-zis, care trebuie executat de acest fir. Totuşi, metoda run() nu este invocată explicit . Ea este invocată de maşina virtuală Java, atunci când firul respectiv este pus în mod efectiv în execuţie. Pentru redefinirea metodei Run este necesar sa creem o subclasă a clasei Thread sau sa creem o clasă cu interfaţa Runnable, şi să dăm o instanţă a acestei clase ca argument constructorului clasei Thread. După ce firul de execuţie a fost creat (de exemplu prin expresia new Thread()), el există în memorie, dar înca nu poate fi executat. Se găseşte, deci, în starea " nou creat " (engleza: born). Pentru a-l face gata de execuţie, pentru firul respectiv este invocată metoda start(). Având în vedere cele de mai sus, punem în evidenţă urmatoarele stări în care se poate găsi un fir de execuţie pe durata ciclului său de viaţă : - nou creat (engleză: born) - este starea în care se găseşte imediat ce a fost creat prin operatorul new; în această stare, firul nu poate fi executat; - gata de execuţie (engleză: ready) - este starea în care firul poate fi pus în execuţie; punerea efectivă în execuţie se face de către maşina virtuala Java atunci când procesorul este liber şi nu sunt gata de execuţie fire de prioritate superioară; - în execuţie (engleză: running ) - este starea în care procesul se execută efectiv (ocupă procesorul); - adormit (engleză: sleeping ) - este starea de oprire temporară, ca urmare a invocării metodei sleep(); - blocat (engleză: blocked ) - este starea în care aşteaptă incheierea unei operaţii de intrare/ieşire; - în aşteptare (engleză: waiting ) - este starea în care firul se găseşte din momentul în care se invocă metoda wait(), până când primeşte o confirmare dată prin invocarea metodei notify(); - mort (engleză: dead ) - este starea în care intră firul de execuţie dupa ce s-a încheiat executarea metodei run().
191. Interfaţa Runnable Interfaţa java.lang.Runnable trebuie implementată de orice clasă care nu este descendentă a clasei java.lang.Thread, dar ale cărei instanţe trebuie tratate ca nişte fire de execuţie. Singura metodă a acestei interfeţe este public void run() care are acelaşi rol cu cea din clasa Thread. Necesitatea implementării interfeţei Runnable apare atunci când dorim să creem o clasa de fire de execuţie care nu extinde clasa Thread. Motivul ar putea fi, de exemplu, cel că clasa nou creată, B, trebuie sa extindă o alta clasă, A, care nu este descendentă a clasei Thread Se ştie că în Java nu există moştenire multiplă, deci clasa B nu poate avea ca superclase atât clasa A, cât şi clasa Thread. În acest caz, vom crea o clasă B care extinde clasa A şi implementeaza interfaţa Runnable , care
