Programul 1.1. Salut.java

Transcription

1 1. COMPENDIU JAVA Prezenta lucrare presupune că cititorul deţine un nivel minimal de cunoştinţe despre programarea în limbajul Java. Există deja suficientă literatură legată de programarea în Java [1, 5, 67, 4, 34]. În acest capitol venim în sprijinul "aducerii aminte" prin mai multe exemple de programe Java. Vom prezenta mai întâi câteva exemple simple. Apoi facem un sumar al limbajului Java prin comparaţii cu C++. Prezentăm apoi câteva aspecte Java legate de tratarea excepţiilor şi de interfeţe. Capitolul se va încheia cu alte câteva exemple simple de programe Java Primele exemple Specificul Java oferă două tipuri de programe: aplicaţii de sine stătătoare, numite în terminologia Java standalone; programe activabile prin intermediul navigatoarelor Web, numite applet-uri Programul standalone Salut Fişierul sursă poartă numele Salut.java şi este prezentat în programul 1.1. public class Salut{ public static void main(string a[]) { System.out.println("Salut"); // Salut.main // Salut Programul 1.1. Salut.java Mai întâi câteva precizări, care reprezintă de fapt şi primele reguli Java. Un program Java constă din definirea şi instanţierea unei clase. Numele textului sursă este format din numele clasei urmat de sufixul.java. Unele programe pot conţine în acelaşi text sursă mai multe clase, dar atunci numai una dintre ele va fi vizibilă în exterior, celelalte fiind numai de uz intern. 17

2 Un program standalone trebuie să conţină metoda statică main. Ea are ca parametru un tablou având ca şi elemente şiruri de caractere. Fiecare element al tabloului conţine un argument transmis în linia de comandă ce lansează programul în execuţie. Tipărirea este executată de către metoda println a obiectului out din clasa System. Compilatorul Java poartă numele de javac. Lansarea compilării programului se face cu comanda: javac Salut.java Rezultatul compilării este depus în fişierul Salut.class, care conţine codul JVM echivalent. Interpretorul standard Java poartă numele java. El preia codul JVM din Salut.class şi-l execută (interpretativ). Execuţia interpretativă se lansează prin comanda: java Salut Ca efect, pe ecran se va afişa, pe linie nouă: Salut Applet-ul SalutAp Exemplul din secţiunea precedentă, scris ca un applet, este prezentat în programul 1.2. Textul sursă conţine şi patru linii de comentarii, scrise ca în C++. import java.applet.*; import java.awt.*; public class SalutAp extends Applet { public void paint(graphics g) { g.drawstring("salut",10,50); // SalutAp.paint // SalutAp Programul 1.2. SalutAp.java Mai întâi se declară folosirea de metode ale pachetelor applet şi awt. Apoi se indică faptul că clasa SalutAp extinde (este o subclasă pentru) clasa Applet. 18

3 Scrierea textului se face prin intermediul metodei paint. Aceasta realizează rescrierea metodei paint din java.awt.component, având rolul de a "picta" un obiect grafic g. Concret, este vorba de scrierea unui string începând de la pozitia (x= 10 pixeli spre dreapta, y = 50 pixeli în jos). Compilarea sursei se face folosind aceeaşi comandă de compilare: javac SalutAp.java care generează codul de octeţi echivalent sursei în fişierul SalutAp.class. Pentru lansarea în execuţie a acestui applet este nevoie de un navigator Web: Netscape, Mozilla, Konqueror, InternetExplorer etc. Aceste navigatoare operează peste o platformă grafică oferită de către sistemul de operare: Windows [100] (platformele Microsoft), respectiv X-window [58] (platformele Unix). În funcţie de platformă, Pachetul Java oferă pentru testarea applet-urilor, interpretorul appletviewer care este, de fapt, un navigator Web specializat. În textul sursă HTML [59, 85] transmis navigatorului Web trebuie inserată sursa din programul 1.3. <APPLET code="salutap.class" width="500" height="100"> </APPLET> Programul 1.3. SalutAp.html Numele fişierului.java trebuie să coincidă cu numele clasei, însă numele fişierului HTML poate fi diferit (noi l-am luat acelaşi din comoditate). Prin acest text, care este un tag HTML, se cere navigatorului să-şi încarce codul JVM din fişierul SalutAp.class şi să-l execute (interpretativ). Figura 1.1. Imaginea SalutAp prin Mozilla 19

4 În fig. 1.1 este prezentat rezultatul execuţiei folosind navigatorul Mozilla. Dacă se doreşte utilizarea interpretorului standard Java appletviewer, se va lansa comanda: appletviewer SalutAp.html Imaginea ferestrei este prezentată în fig. 1.2 Figura 1.2. Imaginea SalutAp prin appletviewer Un program ce poate rula alternativ standalone sau applet Pare cel puţin interesant să vedem un program care să poată rula, după preferinţă, ori ca aplicaţie standalone ori ca applet. Unul dintre cele mai simple programe de acest tip este programul 1.4. import java.awt.*; import java.awt.event.*; import java.applet.*; public class PrimCompus extends Applet { public static void main(string a[]) { PrimCompus oprimcompus = new PrimCompus(); Frame oframe = new Frame("Fereastra standalone"); WindowListener l=new WindowAdapter() { public void windowclosing(windowevent e) { System.exit(0); ; oframe.addwindowlistener(l); oframe.setsize(250,350); oframe.add("center", oprimcompus); oframe.show(); oprimcompus.init(); // PrimCompus.main 20

5 public void init() { // PrimCompus.init public void paint(graphics g) { g.drawstring("un sir in fereastra",50,60); // PrimCompus.paint // PrimCompus Programul 1.4. PrimCompus.java Clasa PrimCompus extinde clasa Applet spre a se putea comporta ca şi un applet. De asemenea, în cadrul ei se defineşte metoda main, care este invocată la lansarea ca şi aplicaţie standalone. Să urmărim mai întâi comportarea ca şi applet. În momentul lansării dintr-un navigator, acesta (navigatorul) caută metoda init pe care o lansează în execuţie. În exemplul nostru metoda init este vidă. În continuare (după cum am arătat şi la exemplul SalutAp), dacă în cadrul clasei este definită metoda paint, atunci se lansează în execuţie aceasta. În cazul nostru va afişa un string în fereastră. Pentru lansarea din navigator, este suficient ca documentul html să aibă conţinutul din programul 1.5. <html> <title>fereastra applet </title> <Applet code="primcompus.class" width=250 height=350> </Applet> </html> Programul 1.5. PrimCompus.html Spre a se deosebi de aplicaţia standalone, am precizat şi titlul ferestrei. Execuţia programului din Mozilla este ilustrată în fig. 1.3 Figura 1.3. Imaginea PrimCompus prin Mozilla 21

6 Pentru ca programul să poată fi rulat, cu (aproape) acelaşi efect, în cadrul metodei main trebuie executate câteva acţiuni, de altfel specifice interfeţelor grafice de tip standalone. Mai întâi am definit şi construit obiectul oprimcompus de tipul clasei. Apoi am definit un obiect oframe de tip Frame (tipul clasic de fereastră din pachetul awt). Am fixat titlul acestei ferestre şi dimensiunile ei (în pixeli). Am construit obiectul l, de tip WindowListener, definit printr-o clasă internă, anonimă, de tip WindowsAdapter. Rolul acestui obiect este de a intercepta evenimentul de apăsare a butonului de distrugere a ferestrei şi de a termina apoi programul. (Ca rezultat al compilării, din această clasă anonimă se va crea fişierul PrimCompus$1.class) Am adăugat, în poziţia centrală a obiectului oframe obiectul oprimcompus şi am cerut ferestrei să devină vizibilă. În sfârşit, am lansat metoda init a obiectului oprimcompus, după care comportarea va fi ca şi la applet: va căuta metoda paint şi va afişa stringul în fereastră. Rezultatul execuţiei va fi cel din fig Figura 1.4. Imaginea PrimCompus ca aplicaţie standalone Acces la argumentele liniei de comandă Un program standalone constă din una sau mai multe definiţii de clase, fiecare dintre acestea aflându-se în propriul fişier *.class. Una dintre aceste clase trebuie să conţină metoda main(). Pentru a lansa programul, trebuie lansat interpretorul java cu numele clasei care conţine metoda main. Aceasta are prototipul: public static void main ( String argv[] ). Interpretorul Java execută codul până când metoda main execută un apel System.exit sau până la sfârşitul codului metodei (atingerea acoladei de închidere a metodei). Din acel moment, se aşteaptă terminarea tuturor 22

7 thread-urilor (firelor de execuţie) care încă nu s-au terminat şi apoi execuţia se termină. În momentul lansării în execuţie, parametrii transmişi prin linia de comandă sunt depuşi în vectorul de string-uri notat mai sus prin argv. De aici utilizatorul le poate accesa. De exemplu, programul 1.6 afişează toate aceste argumente (tabloul de string-uri din linia de comandă l-am notat cu a). public class Echo { public static void main(string a[]){ System.out.println("Urmeaza cele "+a.length+" argumente:"); for(int i=0;i<a.length;i++) System.out.println(a[i]); // Echo.main // Echo Programul 1.6. Echo.java Trebuie observate diferenţele faţă de C. În C, funcţia main are două argumente, un întreg şi un tablou de pointeri, notate de obicei de obicei argc argv, indicând numărul de argumente şi pointerii la string-urile transmise ca argumente. În Java apare doar tabloul de string-uri, notat de obicei argv, pentru că numărul de elemente este dat de argv.length, câmpul ce indică pentru un obiect tablou numărul de elemente. Tot spre deosebire de C, după cum se poate vedea dacă se rulează programul, numele comenzii nu este considerat argument al liniei de comandă. Accesul la variabilele de mediu Java nu permite accesul la variabilele de mediu ale sistemului de operare sub care se rulează. Această interdicţie este impusă deoarece aceste variabile depind de sistemul concret, deci nu asigură independenţa de platformă. Mediul Java oferă o modalitate proprie, independentă de platformă, de a defini o listă de proprietăţi sistem. Cititorul interesat poate să consulte [44, 10] în acest scop Scurtă prezentare a limbajului Java Java comparat cu C şi C++ După cum se ştie, Java s-a născut din C şi C++. Este deci normal ca aceste limbaje să aibă trăsături comune, precum şi diferenţe. Deoarece nu avem în intenţie o prezentare exhaustivă a limbajului Java, preferăm o prezentare a sa relativă la aceste limbaje. Lista similarităţilor şi a deosebirilor este actualizată 23

8 cu fiecare nouă distribuţie Java. De exemplu, lucrările [44, 4] prezintă aceste elemente. Noi vom prezenta deosebirile şi asemănările în ipoteza că cititorul cunoaşte, la un nivel minimal, limbajele C++ şi (eventual) Java. Java nu acceptă mecanismul typedef, nici noţiunea de preprocesor. În consecinţă, construcţiile #define, #if #include ş.a. nu sunt admise. Dispare deci noţiunea de fişier header. De asemenea, Java nu suportă tipul de date enum. În locul lui lui define, în Java se pot declara constante cu ajutorul cuvântului cheie final. Aceste constante pot fi folosite ca înlocuitori pentru tipul enum. Ca şi C++, Java operează cu tipul class, dar nu suportă nici tipul struct, nici union. Programele standalone C++ cer o funcţie numită main. Pe lângă aceasta, în programele C++ pot să apară numeroase alte funcţii, atât independente, cât şi funcţii membre ale claselor (metode). În Java, funcţiile sunt numai membre ale claselor (metode), deci nu există funcţii independente, neaparţinând claselor. De asemenea, Java nu admite funcţii globale şi date globale. În Java, toate clasele sunt, în ultimă instanţă, descendente din clasa Object. În schimb, în C++ este posibilă crearea unor arbori de clase fără nici o legătură între ei. Toate definiţiile de funcţii (metode) în Java sunt conţinute în interiorul claselor cărora le aparţin. În C++ este permisă definirea lor în afara claselor. De asemenea, în C++ este permisă definirea explicită de funcţii inline, în timp ce în Java această opţiune este lăsată pe seama interpretorului JVM. Atât C++ cât şi Java permit definirea de variabile şi metode clasă (static), invocabile independent de existenţa sau nu a unor instanţieri ale clasei respective. Java permite utilizarea conceptului interface. Prin intermediul ei se pot defini prototipuri de metode şi eventual declararea de constante. Într-o interfaţă nu sunt permise definirea de metode, nici declararea de variabile membru. C++ nu suportă conceptul de interfaţă. Atât Java, cât şi C++ admit clase abstracte. Vom reveni asupra acestui concept. Java nu permite moştenirea multiplă. Într-o oarecare măsură, utilizarea interfeţelor suplineşte în Java această absenţă. Moştenirea simplă este, conceptual la fel în Java ca şi în C++, însă în partea de implementare diferenţele sunt mari. Java nu acceptă instrucţiunea goto, deşi goto este cuvânt rezervat (dar nefolosit)! În schimb, Java permite break şi continue, atât în forma existentă în C++, cât şi extinderile break şi continue etichetate. Acestea din urmă nu sunt suportate de C++. În forma simplă ele comandă părăsirea, respectiv reiterarea celui mai interior corp al unui ciclu. Cele etichetate acţionează în acelaşi mod, dar asupra ciclurilor (mai exterioare) marcate printr-o 24

9 etichetă. Aceste extinderi pentru break şi continue permit înlocuirea, în toate cazurile de structuri de control fireşti, a instrucţiunii goto [16]. Java nu permite suprapunerea operatorilor. De asemenea, nu permite conversia implicită (automată) de tip. Spre deosebire de C++, Java are obiecte de tip String, obiecte nemodificabile. Obiectele Java de tip StringBuffer permit şi modificări, precum şi conversii facile între cele două tipuri de string-uri. Tablourile în Java sunt obiecte. Într-un tablou Java, elementele lui sunt indexate de la 0 la length-1. length este o variabilă a unui obiect tablou, indicând lungimea maximă a domeniului de indexare. Elementele unui tablou sunt (evident) toate de acelaşi tip, care poate fi orice, inclusiv un alt tablou. Astfel se implementează tablourile multidimensionale. Java permite operaţia de atribuire la nivel de tablou. Dimensiunea unui tablou se fixează dinamic, nu static ca în C++. Spre deosebire de C++, în Java se controlează, la orice invocare, limitele indicilor, evitându-se astfel indexarea în afara domeniului. Java nu permite operarea cu pointeri, implicit nu există nici aritmetica de pointeri. Automat, a dispărut şi echivalenţa dintre pointeri, nume de tablouri etc. Natural, absenţa pointerilor implică absenţa operatorului de selecţie din pointer "->". Operatorul rezoluţie scope "::" din C++ nu este folosit în Java. Toate selecţiile se fac cu operatorul ".". Pentru expresiile condiţionale Java s-a introdus tipul boolean, inexistent în C++. A dispărut astfel statutul de TRUE pentru o valoare nenulă şi FALSE pentru o valoare nulă, aşa cum stau lucrurile în C. În ceea ce priveşte tipurile de date primitive, ele sunt aproape identice cu cele din C. Vom reveni cu detalii într-o secţiune ulterioară. Operatorii sunt, practic cei din C. Operatorii pe biţi acţionează numai asupra întregilor. Operatorul >> face deplasarea la dreapta cu propagarea bitului de semn, iar un nou operator, >>>, face aceeaşi deplasare cu completarea de zerouri pentru biţii eliberaţi. Singura suprapunere, implicită, este += ce poate indica şi concatenarea de string-uri. Cât despre spaţiile de nume: în Java orice variabilă (câmp) şi orice metodă este declarată numai în interiorul unei clase şi face parte din structura acesteia. De asemenea, fiecare clasă face parte dintr-un pachet. Pachetele Java sunt astăzi cele care permit o mare dezvoltare şi extindere a platformelor Java. O colecţie de clase înrudite, cu ţinta spre un anumit tip de prelucrări, constituie în fapt o bibliotecă ce poate fi integrată în orice aplicaţie Java. Este suficient să amintim aici că, dacă la Java 1.0 ([10]) erau opt pachete standard, la Java 1.2 erau 58 [44] şi numărul pachetelor, standard sau de aplicaţie este în continuă creştere. Accesul la nume se poate face: 25

10 implicit - între clasele aceluiaşi pachet; declarat public - accesibil de oriunde; declarat protected - accesibil din clasă sau clasele subordonate; declarate private - accesibil numai în interiorul clasei. În C++ orice nume (variabilă, constantă, nume de funcţie etc.) trebuie mai întâi declarat sau definit şi abia apoi utilizat. În Java această restricţie nu mai există. Constructorii, atât în Java cât şi în C++ pot fi suprapuşi. În Java, toate obiectele sunt transmise prin referinţă, eliminându-se astfel constructorii de copiere din C++. În Java nu există destructori! Interpretorul JVM are un thread specializat, care rulează în continuu (cu prioritatea cea mai mică), numit garbage collector. Acesta face oficiile de destructor atunci când un obiect nu mai este referit de nicăieri. Garbage collection Obiectele Java îşi ocupă memoria necesară în mod dinamic, în faza de execuţie. Alocarea de memorie este făcută automat, deci lipsesc apelurile similare lui malloc. De asemenea, nu se face eliberarea explicită a spaţiului ocupat, deci nu există apeluri similare lui free din C şi C++. Distrugerea obiectelor se face automat, printr-un mecanism clasic de garbage collection [76, 17]. Eliberarea spaţiului ocupat de un obiect se face, fără ştirea utilizatorului, după ce obiectul nu mai este vizibil şi nici în viaţă. Funcţiile pot fi suprapuse, atât în C++ cât şi în Java. Spre deosebire de C++, în Java nu sunt admişi parametri cu valori implicite, nici funcţii cu un număr variabil de parametri. La fel ca şi în C++, Java permite metode native. Spre deosebire de C++, Java nu suportă template, nici funcţii generice. Cuvântul virtual nu apare în Java. Toate metodele nestatice din Java sunt legate dinamic, aşa că virtual din C++ îşi pierde semnificaţia. Asupra tratării excepţiilor vom reveni. Spre deosebire de C++, Java oferă o serie de structuri specializate, numite containere de obiecte. Relevante în acest sens sunt containerele Vector şi Hashtable. În fine, comentariile speciale /** */ sunt procesate prin javadoc şi permit elaborarea automată de documentaţii. 26

11 Modificatorii static, final, syncronized şi native Modificatorul static Poate preceda un câmp (variabilă) sau o metodă a unei clase, pentru a specifica faptul că elementul respectiv este propriu clasei respective şi că el nu depinde de una sau alta dintre obiectele rezultate din instanţierile clasei respective. Deci câmpul (variabila) are aceeaşi valoare indiferent de instanţiere, iar metoda funcţionează independent de instanţiere. Un element static poate fi accesat indiferent de faptul că există sau nu o instanţiere a clasei respective. De exemplu, variabila out din clasa System poate fi accesat chiar dacă nu există o instanţiere a acestei clase, motiv pentru care putem invoca metoda println a lui: System.out.println(" "); Modificatorul final Ataşat unei variabile sau unei metode indică faptul că elementul respectiv este în ultima lui formă. Din această cauză, nici variabila, nici metoda finală nu mai pot fi suprascrise în cadrul subclaselor derivate. O variabilă finală se comportă ca şi o constantă. Modificatorul syncronized Poate să caracterizeze o metodă (există şi instrucţiunea syncronized asupra căreia vom reveni). Dacă două sau mai multe thread-uri invocă o aceeaşi metodă sincronizată pentru un acelaşi obiect, atunci doar unul dintre ele o execută, celelalte aşteaptă ca acesta să îşi termine invocarea ei, după care un altul îşi porneşte exclusiv execuţia ş.a.m.d. Deci, dacă două thread-uri solicită pentru acelaşi obiect a o metodă sincronizată met, adică ambele invocă a.met, atunci ele vor fi executate unul după celălalt. Dacă însă există două obiecte diferite a şi b, atunci două thread-uri pot să execute simultan apelurile a.met() b.met(). Modificatorul native Indică faptul că metoda respectivă este descrisă într-un fişier extern provenit dintr-o altă compilare. De exemplu dintr-o compilare C. Evident, acest gen de metode nu mai păstrează independenţa de platformă. 27

12 Cuvinte cheie Java utilizează următoarele cuvinte cheie: abstract boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new null package private protected public return static short super switch synchronized this throw throws transient try void volatile while Tipuri de date primitive Unicode: codificarea şi evitarea caracterelor Java este unul dintre puţinele limbajele de programare care încalcă un principiu care părea statuat de facto: caracterele Java şi string-urile sunt codificate în codul Unicode pe 16 biţi. Asta face ca setul de caractere să fie potrivit şi pentru alte caractere, neexistente în alfabetul englez. Setul Unicode este efectiv un supraset al lui ASCII, deci textele ASCII au aceeaşi reprezentare, dar fiecare octet ASCII este completat cu câte un octet semnificativ cu valoarea 0 (neinterpretat de maşinile ce văd doar ASCII). Cititorii care doresc să cunoască întregul set de caractere Unicode, pot consulta Specificarea caracterelor ASCII tipăribile se face ca şi în C. Mecanismul de evitare a caracterelor din C se păstrează şi se mai introduce un mod suplimentar de specificare, astfel: 28 \uxxxx unde xxxx sunt patru cifre hexa; \xxx unde xxx sunt trei cifre octale. \n \r \t \f \b \ \ \\ sunt cele cunoscute din C. Tipul char Se reprezintă pe doi octeţi în Unicode şi respectă convenţiile de conversie la întregi din C. String-urile Se scriu ca şi în C (între ghilimele). Spre deosebire de C, în Java nu există continuare (linie terminată cu \ în C sau C++) pentru string-urile lungi. În schimb, operatorul + Java este extins şi pentru concatenarea de

13 string-uri. Deci şirurile lungi se scriu folosindu-se operatorul + de concatenare. Există tipul de date String. Tipul Boolean Este nou introdus în Java (nu este în C). În schimb dispare convenţia C cu 0 având valoarea false şi diferit de 0 având valoarea true. Un tip Boolean nu este un întreg şi nici nu poate fi convertit la acesta. Tipurile întregi La tipurile întregi, împărţirea cu 0 activează excepţia numită ArithmeticException. Constantele întregi lungi au după şirul de cifre litera l sau L. Constantele octale încep cu 0, iar cele hexazecimale cu 0x sau 0X. Tipurile flotante Pentru tipurile flotante există constantele predefinite: POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN (Not a Number). La tipurile flotante depăşirile nu se semnalează, ci rezultatul poate fi unul dintre constantele de mai sus. Există, de asemenea, zero negativ şi zero pozitiv. Constantele flotante se pot specifica plasând la sfârşitul scrierii numărului litera f sau F pentru simplă precizie, respectiv cu d sau D pentru dublă precizie. Tabelul următor descrie tipurile de date primitive. Tip Conţinut Valoare implicită Lungime Boolean true sau false false 1 bit Char caracter Unicode \u biţi Byte întreg cu semn 0 8 biţi Short întreg cu semn 0 16 biţi Int întreg cu semn 0 32 biţi Long întreg cu semn 0 64 biţi Float standard IEEE simplă precizie biţi Double standard IEEE dublă precizie biţi 29

14 Tipul referinţă obiect Tipurile de date neprimitive sunt obiecte, în care includem şi tablouri. Ele sunt numite în Java tipuri referinţă, deoarece sunt manevrate prin adresă: compilatorul pune adresa unui obiect sau tablou într-o variabilă şi aşa este transmis către metode. Prin contrast, tipurile primitive sunt manevrate prin valoare. Deoarece obiectele sunt transmise prin referinţă, este posibil ca două variabile diferite să se refere la acelaşi obiect. De exemplu: Button p, q; p = new Button(); q = p; p.setlabel( Ok ); String s = q.getlabel(); Aici, s va avea valoarea Ok. int i = 3; int j = i; i = 2; Aici, i este 2 şi j este 3 (deci nu e valabil acelaşi lucru la datele primitive!). Copierea obiectelor şi compararea lor Din cauza referinţei, atribuirea între obiecte nu face copiere. De exemplu, Button a = new Button( Ok ); Button b = new Button( Cancel ); a = b; Aici, a şi b punctează ambele la butonul Cancel, iar butonul Ok este pierdut. Pentru a se face o atribuire veritabilă, trebuie executată o operaţie de copiere a componentelor de la sursă la destinaţie. Majoritatea tipurilor de date standard au definită o metodă clone(), care execută efectiv copierea, componentă cu componentă. O astfel de atribuire funcţionează ca în exemplul următor, în care variabila c se va referi la un duplicat al obiectului b: Vector b = new Vector; c = b.clone(); Pentru copierea de tablouri, se foloseşte metoda: System.arraycopy(sursa,inceput,destinatie,inceput,lungime) Obiectele nu pot fi comparate nici măcar cu egalitate. Utilizatorul îşi poate defini proceduri proprii de comparare. Unele clase au, în acest scop, o metodă numită equals(). 30

15 Din raţiuni de portabilitate, de independenţă de platformă şi de siguranţă, nu există pointeri! Deci, nu se pune problema referirii, dereferirii, conversiei referinţelor la tablouri în întregi etc. Constanta null indică inexistenţa unui obiect sau a unui tablou Tratarea excepţiilor O excepţie Java este un obiect care descrie o condiţie (situaţie) excepţională ce are loc într-o secvenţă de cod. Atunci când are loc o condiţie excepţională Java creează un obiect reprezentând eroarea şi aruncă excepţia metodei care a cauzat eroarea. Metoda poate să aleagă între a prelua excepţia (şi a o trata), sau a o ignora. În oricare din cazuri la un anumit moment excepţia este prinsă şi tratată. Excepţiile pot fi generate de mediul de execuţie Java, sau de programator. Excepţiile generate de Java se referă la erori fundamentale care violează regulile limbajului sau ale mediului de execuţie. Excepţiile aruncate de programator sunt folosite de regulă pentru a raporta nesatisfacerea precondiţiilor apelului unei metode. Pentru rezolvarea problemelor legate de excepţii sunt folosite cinci cuvinte rezervate: try, catch, throw, throws şi finally. Iată cum funcţionează mecanismul: secvenţa de instrucţiuni care este susceptibilă de erori este pusă întrun bloc try; dacă se generează o excepţie, datorită execuţiei blocului de instrucţiuni, atunci Java creează un obiect excepţie şi îl aruncă metodei (spre secvenţa respectivă); dacă dorim să prindem excepţia, atunci folosim clauza catch, imediat după blocul try; dacă vrem să provocăm (aruncăm) o anumită excepţie atunci folosim throw; excepţiile fundamentale sunt provocate automat de către Java; dacă anumite instrucţiuni trebuie să fie executate înainte de a ieşi (normal sau anormal) din metodă, atunci punem instrucţiunile întrun bloc finally; în antetul de definire a unei metode, pentru a specifica că metoda este posibil să arunce o excepţie, trebuie specificată excepţia (excepţiile) folosind o clauză throws Forma generală pentru manipularea excepţiilor este: try {... // Bloc de instructiuni in care pot apare exceptii 31

16 32 catch (TipExceptie1 objexceptie1) {... // Tratare exceptie TipExceptie1 catch (TipExceptie2 objexceptie2) {... // Tratare exceptie TipExceptie finally {.. // Bloc de instructiuni ce se executa // inainte de a se incheia blocul try Pentru comoditate, în multe dintre programele noastre de test evităm folosirea lui try - catch adăugând la definirea lui main: public static void main(string a[]) throws Exception { Aceasta provoacă tratarea automată a excepţiilor de către JVM. Tot pentru comoditate, spre a nu "ne bate capul" cu prea multe catch şi a inventaria toate excepţiile posibile de aruncat dintr-un bloc try, plasăm un singur catch sub forma: catch(exception e) { System.out.println(e.getMessage()); // eventual lipseşte e.printstacktrace(); System.exit(1); // eventual lipseşte Atragem însă atenţia că în cadrul programelor reale trebuie tratată fiecare excepţie în parte în conformitate cu cerinţele problemei de rezolvat! În caz contrar pot apărea conflicte serioase la interfaţa cu alte componente ale aplicaţiei! Într-unul dintre capitolele următoare vom prezenta o aplicaţie mai mare în care vom aborda "cu simţ de răspundere" tratarea excepţiilor. Aruncarea unei excepţii se face prin: new ExceptieAruncata (... ); Toate tipurile de excepţii sunt subclase ale clasei java.lang.throwable cu două subclase: java.lang.exception şi java.lang.error. Pentru fiecare eroare apărută se instanţiază un obiect al uneia dintre cele două subclase. Printre altele, fiecare obiect excepţie conţine un string ce are ca valoare mesajul explicativ al excepţiei sau erorii respective. Excepţiile generate (aruncate) prin program trebuie să fie de tip Exception. Excepţiile de tipul Error sunt generate de mediu şi nu pot fi prinse de program (de exemplu blocarea mediului Java datorită memoriei insuficiente). O parte din ierarhia de excepţii şi erori este: Throwable Exception IOException

17 FileNotFoundException... RuntimeError ArithmeticException IndexOutOfBoundsException ArrayIndexOutOfBoundsException StringIndexOutOfBoundsException NullPointerException Error VirtualMachineError Istanţierea şi distrugerea obiectelor. Constructori Instanţierea Instanţierea (crearea) unui obiect se face, după cum am mai arătat, folosind new. Rutina care se execută în momentul instanţierii poartă numele de constructor. Din punct de vedere formal, un constructor este o metodă care: poartă acelaşi nume cu cel al clasei, nu se specifică void la tipul întors, şi nu conţine return în interiorul corpului. Dacă nu se specifică nici un constructor, atunci se generază automat un constructor vid, fără parametri. E posibil să se definească mai mulţi constructori. Mai mult, unii pot să-i folosească pe alţii. Avem astfel de-a face cu o suprapunere (suprascriere) a constructorilor. În continuare exemplificăm prin câteva variante de constructori pentru clasa Cerc. La unele dintre ele vom folosi variabile locale - parametri şi câmpuri de date - cu aceleaşi nume, diferenţierea dintre ele făcându-se prin cuvântul rezervat this. public class Cerc { public double x, y, r; public Cerc (double x, double y, double r) // Centrul (x,y), raza r {this.x = x; this.y = y; this.r = r; public Cerc (double r) // Centrul (0,0), raza r {x = 0.0; y = 0.0;this.r = r; public Cerc (Cerc c) // Copiere a altui cerc {x = c.x; y = c.y; r = c.r; public Cerc () // Centrul (0,0), raza 1 {x = 0.0; y = 0.0; r = 1.0;

18 Singura restricţie la constructorii multipli este aceea că orice doi constructori diferiţi trebuie să aibă liste de parametri la care cel puţin o pereche de parametri corespunzători să difere. De exemplu, primul şi al doilea constructor diferă prin parametrul al doilea, prezent doar la primul constructor; al doilea şi al treilea constructor au numai câte un parametru dar aceştia sunt de tipuri diferite ş.a.m.d. Pentru a apela un constructor, în cadrul unui new numele clasei va avea argumentele dorite, din care compilatorul va deduce despre care constructor este vorba. De exemplu, următoarele linii au acelaşi efect: Cerc c = new Cerc(); c.x = 1.0; c.r = 0.5; Cerc c = new Cerc (1.0, 0.0, 0.5); Cuvântul this poate să apară într-un constructor pentru a desemna un alt constructor din aceeaşi clasă. De exemplu, cei patru constructori de mai sus se pot defini şi astfel: public class Cerc { public double x, y, r; public Cerc (double x, double y, double r) // Centrul (x,y), raza r {this.x = x; this.y = y; this.r = r; public Cerc (double r) // Centrul (0,0), raza r {this(0.0,0.0,r); public Cerc (Cerc c) // Copiere a altui cerc {this(c.x,c.y,c.r); public Cerc () // Centrul (0,0), raza 1 {this(0.0,0.0,1.0); Singura restricţie de folosire a lui this pe post de constructor într-un alt constructor este aceea că apelul this trebuie să apară ca primă instrucţiune în corpul noului constructor. După acest apel pot să urmeze şi alte instrucţiuni. Distrugerea obiectelor Distrugerea obiectelor se face automat prin mecanismul de Garbage Collection care este un thread (fir de execuţie) de prioritate minimă. El culege zonele de memorie după ce acestea nu mai sunt folosite şi eliberează spaţiul ocupat de ele. Aceasta este, după părerea noastră, cea mai mare diferenţă de stil de programare între Java şi C sau C++. Urmează ca cititorii să se convingă singuri: va părea ciudat, cel puţin la început, să nu gestionezi eliberarea spaţiilor de memorie! Este însă posibil ca eliberarea de spaţiu să se petreacă uneori târziu. Uneori (poate) este utilă forţarea eliberării mai rapide. Iată o posibilă schemă: 34

19 public static void main() { int T = new int[100000]; calcule(t); T = null; // Din acest moment, tabloul poate fi distrus restul calculelor Finalizator de obiecte De multe ori, anumite obiecte sau resurse, cum ar fi spre exemplu, descriptorii de fişiere şi socket-urile, sunt păstrate indefinit. Pentru a forţa eliberarea acestora, se pot folosi metode finalizatori, după modelul de mai jos. protected void finalize() throws IOException { if (fd!= null) close(); // fd este un descriptor Există câteva reguli privitoare la finalizatori: dacă un obiect are o metodă finalizator, atunci ea este invocată înainte de Garbage Collection; nu se garantează ordinea de intervenţie a lui Garbage Collection, de aceea nu se garantează momentele în care intră în lucru finalizatoarele; după finalizator, obiectul nu mai este disponibil! de multe ori, finalizatorul se asociază cu excepţiile Definiri statice (clasă): variabile, metode, iniţializatori Variabile clasă (statice) Variabilele definite într-o clasă au câte o copie pentru fiecare instanţiere a unui obiect. Există însă situaţii în care sunt necesare variabile proprii claselor, ale căror valori nu depind de instanţiere. Acestea vor fi numite variabile clasă sau variabile statice. Metode clasă (statice) Analog cu variabilele clasă, există şi metode clasă, metode independente de instanţiere. În secvenţa de mai jos vom defini două metode de comparare a două cercuri. Una va compara cercul curent cu un alt cerc, iar alta va compara 35

20 două cercuri primite prin parametri. Evident, prima va fi dependentă de instanţiere, dar a doua va fi independentă de instanţiere. public class Cerc { public double x, y, r; public Cerc maxim (Cerc c) { if (c.r > r) return c; else return this; public static Cerc maxim (Cerc a, Cerc b) {if (a.r > b.r) return a; else return b; Apelurile lor pot fi invocate astfel: Cerc a = new Cerc (2.0); Cerc b = new Cerc (3.0); // Doua utilizari ale primei metode Cerc c = a.maxim (b); Cerc d = b.maxim (a); // Utilizare a celei de-a doua metode Cerc c = Cerc.maxim (a,b); În funcţie de context, programatorul va prefera una sau alta dintre metodele maxim. Precizăm câteva caracteristici ale metodelor statice: sunt declarate cu prefixul static; sunt invocate din clase în loc de a fi invocate din instanţe; în astfel de metode nu se foloseşte this! (fapt normal, deoarece this desemnează instanţierea curentă). Iniţializatori statici Atât variabilele instanţă, cât şi cele statice, pot fi iniţializate, prin mecanismele cunoscute din C şi C++. De exemplu, 36 static int nr_cercuri = 0; Java oferă posibilitatea de a face iniţializări mai complexe. Acestea se desemnează prin construcţia static{..., unde între acolade poate să apară o secvenţă de instrucţiuni. Iată de exemplu cum se poate iniţializa un tablou cu valori ale funcţiilor trigonometrice, pentru a evita calcularea lor de fiecare dată:

21 public class Cerc { static private double[] sinus = new double[1000]; static private double[] cosinus = new double[1000]; static { double x, deltax; int i; deltax = (Math.PI / 2) / (1000-1); for (i=0, x=0.0; i<1000; i++, x+=deltax) { sinus[i] = Math.sin(x); cosinus[i] = Math.cos(x); Interfeţe Java Interfeţele Java abstractizează complet metodele unei clase (interfaţa clasei) faţă de orice implementare. Folosind cuvântul rezervat interface (în loc de class) specificăm ce poate face o clasă şi nu cum realizează clasa acel lucru Definirea unei interfeţe Forma generală a definirii unei interfeţe Java este interface nume { tiprezultat1 numemetoda1(listaparametri1); tiprezultatn numemetodan(listaparametrin); tipvariabilafinala1 numevariabilafinala1 = valoare1; tipvariabilafinalak numevariabilafinalak = valoarek; Implementarea interfeţelor Odată ce o interfaţă a fost definită, una sau mai multe clase pot să ofere o implementare a interfeţei. Pentru a implementa o interfaţă, o clasă trebuie să includă cuvântul rezervat implements în antetul definiţiei sale: class NumeClasa [ extends ClasaSuperioara ] implements numeinterfata1 [, numeinterfata2...] { 37

22 după care să definească toate metodele declarate de interfaţă. De asemenea, se impune ca toate metodele interfeţelor să fie declarate public. În consecinţă, clasele care implementează interfaţa trebuie să fie declarate public Apelul metodelor prin variabile referinţe la interfeţe Deoarece metodele unei interfeţe sunt implementate de o clasă, evident că le putem apela prin variabile referinţă la clasa care implementează interfaţa. Java tratează interfeţele ca şi clase pur abstracte. Astfel, putem să definim variabile de tip interfaţă (referinţe la interfaţă); o variabilă interfaţă poate referi o instanţă a unei clase ce implementează interfaţa; dacă o variabilă interfaţă referă o instanţă care implementează interfaţa atunci la apelul unei metode din interfaţă se va apela metoda instanţei (apel conform obiectului referit şi nu conform referinţei - ca şi la redefinirea metodelor în cazul moştenirii) Exemple de programe Java În cele ce urmează prezentăm câteva aplicaţii standalone scrise în Java prin care exemplificăm cele prezentate mai sus Calcule aritmetice simple Distanţa între două puncte Se cere determinarea distanţei euclidiene dintre două puncte ale căror coordonate se dau în linia de comandă sub forma a patru numere. Sursa este dată prin programul 1.7. public class Distanta { 38 public static void main(string a[]) throws Exception { // Determina distanta intre punctele de coordonate (a[0],a[1]), (a[2],a[3]) double x1 = Double.parseDouble(a[0]); double y1 = Double.parseDouble(a[1]); double x2 = Double.parseDouble(a[2]); double y2 = Double.parseDouble(a[3]); System.out.println("Distanta este: "+ // Afiseaza distanta Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)));

23 // Distanta.main // Distanta Programul 1.7. Distanta.java Calculul unor medii ponderate Se cere un program care calculează succesiuni de medii ponderate ale unor note. Ponderile sunt date ca şi argumente în linia de comandă. Notele sunt cerute pe rând de la intrarea standard. Sursa este dată în programul 1.8 import java.io.*; public class MediiPonderate { public static void main(string a[]) throws Exception { int i; String s; BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); double[] p = new double [a.length]; double[] n = new double [a.length]; double medie, total; for (i=0, total=0; i<a.length; i++) { p[i] = Double.parseDouble(a[i]); total += p[i]; // for for (;; ) { for (i=0, medie=0; i<a.length;i++) { System.out.print("Nota "+(i+1)+": "); s = in.readline(); if (s == null) System.exit(0); medie += (p[i]*double.parsedouble(s)); // for medie /= total; System.out.println("Media: "+medie); // for // MediiPonderate.main // MediiPonderate Programul 1.8. MediiPonderate.java 39

24 Figura 1.5. Utilizarea MediiPonderate În fig. 1.5 este prezentat un exemplu de utilizare a programului, pentru medii ponderate cu ponderile 5, 7.5, 2.5 şi 5. (Altfel spus, prima şi ultima notă contează la fel şi împreună cât celelalte două; nota a doua mai mult, a treia mai puţin...): Dacă din greşeală la lansarea programului de mai sus nu se dau ponderi în linia de comandă în momentul lansării, atunci programul va intra în ciclu infinit! Generarea de elemente aleatoare Generarea de parole În administrarea utilizatorilor din reţele este necesară o rezervă de parole cu care să opereze administratorii. Programul care urmează generează aleator 2000 parole de câte 8 caractere, litere mari, litere mici şi cifre zecimale. Sursa este dată în programul 1.9. import java.io.*; import java.util.*; public class GenPasswd { public static void main(string a[]) { String car = "abcdefghijklmnopqrstuvwxyz"+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"+ " "; // Alfabetul StringBuffer lin = new StringBuffer(" Random r = new Random(); // Obiect numar aleator for (int n=0; n<2000; n++) { for(int i=0; i<8; i++) lin.setcharat(i, car.charat( "); // Spatiu pentru // o parola 40

25 Math.abs(r.nextInt())%car.length())); // Genereaza un caracter System.out.println(lin); // Tipareste o parola // for: cele 2000 parole generate // GenPasswd.main // GenPasswd Programul 1.9. GenPasswd.java Generarea de expresii booleene Pentru o culegere de probleme a fost necesară scrierea unor expresii booleene. Acestea trebuie simplificate şi să se construiască circuitele combinaţionale echivalente. Autorii au decis generarea aleatoare a unui anumit număr de variabile, a unui număr oarecare de termeni conjunctivi şi o manieră aleatoare de negare a variabilelor. Programul 1.10 face acest lucru. import java.io.*; import java.util.*; public class GenExpr { public static void main(string a[]) { String var="abcde"; // Variabilele String neg=" -"; // Negare sau nu String s; int v, n, t, i, j, k; Random r = new Random(); // Obiectul numar aleator for (i=0; i<20; i++) { v = 3 + Math.abs(r.nextInt())%3; // Numar de variabile t = 4 + Math.abs(r.nextInt())%8; // Numar de termeni conjunctivi for (s = "f(",k=0; k<v; k++) { s += var.substring(k,k+1); s += (k<v-1)?",":") = "; // for: Partea stanga a definirii functiei for(j=0; j<t; j++) { for (k=0; k<v; k++) { n = Math.abs(r.nextInt())%2; // Alege negare sau nu s +=neg.substring(n,n+1)+var.substring(k,k+1); // Lipeste variabila negata sau nu // for: generat un termen conjunctiv if (j < t-1) s += " V "; // Pune operatorul SAU // for: Expresia booleeana System.out.println(s); // Tipareste expresia generata // for: cele 20 expresii // GenExpr.main // GenExpr Programul GenExpr.java 41

26 Iată, în fig. 1.6, cum arată rezultatul execuţiei acestui program. Figura 1.6. Generarea unor expresii booleene Ordonare linii Programul 1.11 prezintă un exemplu simplu de operare cu string-uri. Se citeşte de la intrarea standard o succesiune de linii. Programul reţine aceste linii şi apoi le afişează în ordine alfabetică a conţinutului lor. Terminarea transmiterii liniilor de la intrarea standard trebuie marcată prin CTRL/Z (cazul Windows), respectiv CTRL/D (cazul Unix), pentru a marca sfârşitul fişierului de intrare standard. import java.io.*; import java.util.*; public class Linii { 42 public static void main(string a[]) { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); String s, d; // String-uri de serviciu Vector ts = new Vector(); // Tabloul de stringuri int n; for(n=0; ; ) { // Citeste linie cu linie si adauga la ts s=null; try { s = in.readline(); // try catch (IOException e) { e.printstacktrace(); // catch if (s==null) break; // S-a tastat sfarsitul intrarii ts.add(s); n++; // for for(int i=0; i<n-1; i++){ // Ordoneaza tabloul

27 for(int j=i+1; j<n; j++) { d=(string)ts.elementat(j); s=(string)ts.elementat(i); if (s.compareto(d) > 0) { ts.set(i, d); ts.set(j, s); // if // for j // for i System.out.println("\nLiniile ordonate lexicografic:\n"); for (int i=0; i<n;i++){ s=(string)ts.elementat(i); System.out.println(s); // Afiseaza liniile // for // Linii.main // Linii Programul Linii.java Iată, în fig. 1.7 o mostră de execuţie a acestui program: Figura 1.7. Ordonarea liniilor 1.6. Thread-uri Java În prezent, tendinţele în programarea concurentă utilizează în loc de proces conceptul de thread [3, 6, 14]. Pachetul java.lang oferă clasa Thread. Aceasta, împreună cu unele metode moştenite de la clasa Object, permit crearea, execuţia, controlul şi sincronizarea thread-urilor. În particular, 43

28 sincronizarea se bazează pe conceptul de monitor. Este cunoscut faptul că operarea multithreading dă multă bătaie de cap programatorilor C şi C++. Programatorii trebuie să-şi implementeze mecanisme proprii de blocare a unor secţiuni critice şi de partajare a unor resurse critice. Primitivele furnizate de Java reduc esenţial acest efort Elemente de limbaj Java în contextul thread-urilor Utilizarea thread-urilor Java este deja bine cunoscută în literatură [14, 32]. Având în vedere faptul că ne vom referi frecvent la o serie de metode specifice lucrului cu thread-uri, considerăm oportună o trecere în revistă a acestora. Pentru detalii se poate consulta [14] Obiecte versus thread-uri Având în vedere importanţa conceptului de thread, prezentăm pe scurt metodele din clasa Object care se referă la thread-uri. Reţinem din clasă doar ceea ce, într-un fel sau altul, poate fi util în context multithreading. Prototipurile metodelor se găsesc în documentaţiile standard [91]. Metodele wait() Pun obiectul în aşteptare până la apariţia unui eveniment. Ultimele două forme indică o durată maximă de aşteptare, fie numai în milisecunde, fie în milisecunde plus nanosecunde. Metodele notify() şi notifyall() Sunt duale metodelor wait(), ele anunţă alte obiecte apariţia unui eveniment. Metoda getclass() Întoarce clasa din care s-a instanţiat obiectul apelant al metodei. Metoda equals() Oferă, prin suprascriere în subclase, posibilitatea de a se defini ce înseamnă egalitatea a două obiecte din clasa respectivă. Implementarea acestei metode trebuie să respecte, pentru orice referiri nenule x, y, z, următoarele condiţii: 44 reflexivitate, adică x.equals(x) trebuie să întoarcă true;

29 simetrie, adică x.equals(y) este true dacă şi numai dacă y.equals(x) este true; tranzitivitate, adică x.equals(y) este true şi y.equals(z) este true implică x.equals(z) este true; consistenţă, adică datele utilizate în metoda equals să nu modifice relaţia între două obiecte; deci, pentru două obiecte x şi y, apelurile multiple x.equals(y) trebuie să întoarcă mereu fie true, fie false; referinţa null: x.equals(null) să fie mereu false. Metoda clone() Creează o copie a obiectului. Înţelesul exact al copiei depinde de clasă. În general următoarele condiţii sunt adevărate: x.clone()!= x este true; x.clone90.getclass() == x.getclass() este true; x.clone().equals(x) este true. Sunt extrem de rare cazurile în care apar mici abateri de la aceste reguli. Este vorba de situaţiile în care suprascrierea lui clone realizează o copiere superficială. Metoda finalize() Poate fi suprascrisă în subclase şi ea conţine acţiunile pe care componenta garbage collection din JVM le va executa imediat înainte de a distruge un obiect. Trebuie remarcat faptul că programul utilizator nu poate stabili cu exactitate momentul şi ordinea de execuţie a metodelor finalize legate de obiecte expirate. Metoda tostring() Întoarce reprezentarea textuală a obiectului. Este utilă uneori în activitatea de depanare. Se recomandă suprascrierea ei dacă se intenţionează a fi utilizată Clasa Thread În acelaşi stil ca şi în secţiunea precedentă, prezentăm principalele metode ale clasei Thread. Dacă se specifică în constructor un obiect tinta, atunci corpul threadului (corpul metodei run) este ataşat acestui obiect. Dacă nu se specifică, 45

30 atunci corpul este ataşat thread-ului nou creat. Prin constructor, sau mai târziu folosind metoda setname(), se poate atribui thread-ului un nume. Dacă nu se specifică altă valoare, atunci numele implicit va fi Thread- +n, unde n este un întreg. Metoda getname() întoarce numele curent al thread-ului. Metoda start() Lansează în execuţie noul thread. Din acest moment, execuţia programului este controlată de (cel puţin) două thread-uri: pe de o parte funcţionează thread-ul curent - cel care execută start(), iar pe de altă parte se lansează în execuţie noul thread, ale cărui instrucţiuni sunt precizate în metoda run(). Metoda run Conţine corpul efectiv al thread-ului. Întreaga activitate curentă a noului thread trebuie descrisă prin suprascrierea acestei metode. Metodele sleep() Pun thread-ul curent în aşteptare un anumit interval de timp. Metodele join() Aşteaptă ca obiectul thread care le apelează să moară. Ultimele două forme limitează timpul maxim de aşteptare. Metoda yield() Cedează controlul de la obiectul thread la planificatorul JVM, pentru a permite unui alt thread (green) să ruleze. Metoda interrupt() Trimite o întrerupere obiectului thread care o invocă. Metodele interrupted() şi isinterrupted() Testează dacă thread-ul apelant a fost întrerupt sau nu. Metoda interrupted() modifică statutul de întrerupt, aşa că la un dublu apel al ei starea thread-ului revine la vechea ei formă. Metoda isinterrupted nu modifică această stare. Metoda isalive() Răspunde dacă obiectul thread apelant este în viaţă sau nu. 46

31 Metoda activecount() Întoarce numărul de thread-uri active din grupul curent. Metoda currentthread() întoarce numărul thread-ului curent. Metoda enumerate() întoarce în tabloul t thread-urile membre ale grupului curent şi ale celor din subgrupuri. Metoda getthreadgroup() întoarce grupul curent de thread-uri. Metoda dumpstack() afişează la ieşirea standard stiva curentă de thread-uri. Metodele stop(), suspend() şi resume() Au fost definite în primele versiuni Java. Ulterior s-a dovedit că folosirea lor poate conduce, în cazul unei proiectări neatente a programului, la impas şi din această cauză începând cu versiunea 1.2 au fost declarate deprecated, motiv pentru care nici noi nu le vom acorda prea mare atenţie. Metoda stop() provoacă oprirea execuţiei unui thread. Metoda suspend() suspendă temporar execuţia thread-ului, reluarea şi continuarea execuţiei făcându-se cu metoda resume() Operaţii asupra thread-urilor Java; creare, terminare Crearea unui thread Crearea unui thread folosind Java API se poate face în două moduri: implementând o clasă derivată din clasa predefinită Thread, clasă care face parte din pachetul java.lang şi ca urmare este importată automat în orice program Java; definind o clasă care implementează interfaţa Runnable. Primul dintre ele constă în a declara o clasă ca subclasă a clasei Thread. În interiorul acesteia se redefineşte metoda run(), metodă care conţine corpul de instrucţiuni ale thread-ului. După aceea, se poate defini şi instanţia noua subclasă. Schematic, crearea se face conform modelului de mai jos. class ThreadPropriu extend Thread { // datele subclasei ThreadPropriu ( /* parametrii constructorului */ ) { // descrierea constructorului public void run() { // defineste corpul thread-ului ThreadPropriu