CAPITOLUL 1 INTRODUCERE N UNIVERSUL OBIECTELOR 1.1 MODELUL OBIECTUAL 1.1.1 CE SUNT OBIECTELE 1.1.2 MODELUL OBIECTUAL.

ELEMENTE DEFINITORII SPECIFICE 1.2 DEFINIREA I CREAREA OBIECTELOR 1.2.1 REPREZENTAREA I FORMALIZAREA OBIECTELOR 1.2.2 INSTANIEREA I INIIALIZAREA OBIECTELOR 1.3 INTERACIUNEA CU I NTRE OBIECTE 1.3.1 INVOCAREA I ACCESAREA OBIECTELOR. STRUCTURI DE DATE ORIENTATE OBIECT 1.3.2 OPERAII, PARAMETRI, METODE I VARIABILE INTERNE

2 2 3 3 4 6 6 8 20 20 20

CAPITOLUL 1
Introducere n universul obiectelor
nainte de alte explicaii i dezbateri mai mult sau mai puin academice, fiindc sintagma cel mai des utilizat este modelul obiectual, credem c este util o clarificare din capul locului a nelesului ct de ct formal sau mcar att ct se poate la acest moment, asupra acestei noiuni. Modelul obiectual reprezint un model de abstractizare i formalizare a soluiilor software la probleme din diverse domenii (n particular i domeniul economic), avnd la baz conceptul de obiect. Domeniul concret, abstractizat n contextul software, l vom numi domeniul afacerii, iar formalizarea acestuia avnd la baz conceptele legate de obiect o vom numi modelul orientat obiect al afacerii. Dincolo de elementele revoluionare n domeniul proiectrii i programrii pe care le promoveaz fa de abordarea structurat, promotorii modelului obiectual au avut n vedere o deschidere ct mai larg spre construirea unor structuri ct mai flexibile din punct de vedere semantic. Prin urmare, pe lng obiectivul creterii productivitii ca urmare a reutilizrii (de la nivelul structurilor conceptuale pn la componentele software concrete), modelul obiectual ncearc s pun la dispoziie un instrumentar care s compatibilizeze ct mai bine abstraciunile din contextul software cu cele din domeniul problemei reale. De altfel, latura semantic constituie unul din factorii cheie ai proliferrii modelului orientat obiect, n special n sfera problemelor legate de implementarea a ceea ce generic este indicat prin logica afacerii, la fel ca i n cazul mediilor vizuale1 care au revoluionat dezvoltarea aplicaiilor prin valorificarea orientrii lor obiectuale.

Prin medii vizuale putem nelege nu doar instrumente pentru construirea grafic a interfeelor utilizator, ci inclusiv pentru proiectarea aplicaiilor (vezi instrumentele CASE) sau asamblarea funcional a componentelor reutilizabile (un exemplu mai recent este cadrul de lucru OpenBlocks, http://dspace.mit.edu/handle/1721.1/41550, rencarnat n Google App Inventor, http://appinventor.googlelabs.com/about/).

Anexe

1.1 Modelul obiectual

Dup cum am afirmat deja, modelul obiectual are la baz un concept ce pare dezarmant de simplu: obiectul. Supra-structurile sintactice i semnatice construite pe aceast baz se pot dovedi ns destul de complexe. Principiul fundamental al modelrii obiectuale const n folosirea recursiv a conceptului de obiect, aa nct everything is an object, inclusiv descrierea formal a obiectelor se bazeaz tot pe obiecte2. Acest prim capitol se concentreaz n primul rnd asupra lmuririlor privitoare la filosofia obiectelor, n programarea aplicaiilor bineneles, i asupra modului n care ar trebui s relaionm cu ele.

1.1.1 Ce sunt obiectele

O posibilitate de a lmuri ce sunt obiectele, n contextul modelrii orientat obiect a realitii, ar fi s rspundem mai nti la o alt ntrebare cu o tent mai concret: Ce putem reprezenta folosind obiectele? Dac ne gndim ns c, de fapt, obiectele ar constitui elementele centrale n contextul modelrii mai sus-amintite, o formulare mai corect a ntrebrii anterioare ar fi, de fapt, Ce putem abstractiza folosind obiectele? n acest sens s-ar putea gsi mai multe rspunsuri posibile, de exemplu: o entitate; un lucru; un concept; ceva, care poate fi recunoscut sau delimitabil, ceva de sine stttor; n general, ceva care poate manifesta existen independent; orice: Everything is an object. La modul cel mai concret, obiectele sunt caracterizate n primul rnd prin identitate, pentru a putea fi recunoscute i difereniate. Prin urmare obiectul reprezint ceva identificabil, identitatea fiind caracteristica sa fundamental. A doua ntrebare tulburtoare, i poate la fel de relevant ca i prima, se refer la: Cum pot fi caracterizate obiectele, n afar de identitate, despre care deja am amintit? Importana acestei ntrebri provine din faptul c, pentru a le putea folosi drept blocuri constructive, obiectele trebuie s aib:
2

Vezi bibliografie despre reflexie i introspecie n limbajul Java.

Anexe o anume reprezentare (imagine) n contextul din care fac parte, cu alte cuvinte s poat fi descrise o anumit utilitate, adic s-i asume anumite responsabiliti, s s manifeste anumite comportamente de interes, o anumit nclinaie ctre socializare, prin urmare posbilitatea formrii de comuniti de obiecte, cu alte cuvinte obiectele ar trebui s fie capabile s se manifeste colectiv.

A treia ntrebare ndreptit spre a lmuri rolul obiectelor ar fi: Ce fac obiectele? se pot asocia, pot forma structuri (compun obiecte de nivel superior), colaboreaz, pentru a-i ndeplini responsabilitile proprii sau colective. Cu alte cuvinte, se cunosc: anumite obiecte au cunotin de existena altor obiecte, i, mai mult, pot comunica ntre ele, eventual pentru a-i cere ajutorul. Pe parcursul capitolului curent i, mai ales, a celor ce urmeaz vom constata c exist mai multe categorii de obiecte sau c obiectele pot fi caracterizate n mai multe moduri, ntre care: obiecte active i obiecte pasive; obiecte procesate i obiecte de control (care gestioneaz desfurarea unui flux de activiti); obiecte entiti i obiecte servicii; obiecte grafice i obiecte ale afacerii; obiecte generice i obiecte derivate; obiecte simple i obiecte compuse; obiecte persistente i obiecte tranziente.

1.1.2 Modelul obiectual. Elemente definitorii specifice

Pornind de la modul (sau modelul) de formulare al ntrebrilor privind obiectele din paragraful anterior, modelele obiectuale de reflectare a problemelor i soluiilor se vor baza, dup cum vom vedea n particular n capitolele urmtoare, pe un ansamblu conceptual fundamentat pornind de la urmtoarele noiuni: 1. identitate, pentru a recunoate, n special n contextul existenei mai multor obiecte (de acelai fel); 2. stare, constnd n suma caracteristicilor sau proprietilor descriptive (informative) i suma cunotinelor (referinelor) ctre alte obiecte;

Anexe 3. comportament, modul de manifestare a obiectelor ca urmare a interaciunii cu alte obiecte; 4. interaciuni, pentru a descrie schimbul de mesaje: cereri i rspunsuri, n contextul realizrii colaborrilor. Limbajele de modelare orientate obiect, cum este UML3, folosesc pentru a reprezenta aceste concepte elemente specifice cum ar fi: 1. atribut, proprietate sau caracteristic informaional a unui obiect; 2. operaie, a. sarcin de care poate fi responsabil, tie s o duc la ndeplinire sau tie s o realizeze, deci o asum, un obiect; b. cerere care poate fi adresat, pe care o poate satisface sau de care poate rspunde un obiect; 3. mesaj, baza comunicrii cererilor i schimbului de informaii ntre obiecte; 4. legtur sau relaie, cale sau canal de comunicare; 5. navigabilitate, direcie de comunicare.
Tabelul 1.1 Sumar al cadrului conceptual pe care se fundamenteaz modelele orientate obiect

Concepte fundamentale Identitate Stare

Limbajul unificat de modelare Atribut

Limbaje de programare orientate obiect

Comportament Interaciuni

Cmp sau variabil de instan Legtur sau relaie i Referin navigabilitate Operaie Metod Mesaj Invocare, apel sau acces

Limbajele de progamare orientate obiect folosesc, pentru a materializa (sau implementa) aceste concepte, elemente specifice cum ar fi: 1. cmp sau variabil de instan, pentru materializarea concret a unui atribut; 2. metod, modul de realizare concret a unei sarcini sau modul de pregtire concret a rspunsului la o cerere; 3. invocare, apel sau access, transmiterea concret a unui mesaj; 4. referin, reprezentnd un canal de comunicare direct.

UML, Unified Modeling Language sau Limbajul unificat de modelare.

Anexe

1.2 Definirea i crearea obiectelor

n paragraful anterior au fost trecute n revist elementele sau conceptele fundamentale ale modelului orientat obiect de reprezentare sau implementare a problemelor i soluiilor ntr-un context computaional. Paragraful curent va ncerca s expliciteze ntr-o prim form aceste concepte, cu ajutorul sau n cadrul limbajelor de programare orientate obiect, n particular n cadrul limbajului Java.

1.2.1 Reprezentarea i formalizarea obiectelor

m primul rnd, dup cum am sugerat deja, cea mai simpl accepiune conceptual a unui obiect ar fi aceea de entitate concret din domeniul problemei. n privina materializrii sau implementrii: logice, n cadrul limbajului Java obiectul reprezint o structur de date (compus) descris printr-o clas (modul), instaniat i gestionat intern printr-o variabil ce va stoca referina (pointer) obiectului (sau instanei); fizice, n cadrul mediului de execuiei al unei aplicaii software sau mediului runtime, obiectul reprezint o structur de memorie gestionat automat ntr-o zon de memorie specific (heap).

Fundamental n formalizarea obiectelor, n majoritatea limbajelor de modelare (UML) sau implementare (Java, C#, C++), este conceptul de clas. Formal, o clas reprezint descrierea unui set de obiecte care partajeaz aceleai atribute, operaii, relaii i semantic (UML). Definirea obiectelor prin intermediul claselor comport ns cteva nuanri: n modelare, clasa este mai aproape de conceptul de tip, adic n sensul definiiei de mai sus: set de obiecte avnd aceleai caracteristici (expun aceeai semantic); n privina limbajelor de programare, clasele se formeaz de fapt dintr-un ansamblu de specificaii: declaraii de membri atribute i operaii; blocuri de implementare a operaiilor sau metode; metode de iniializare a obiectelor sau constructori.

Anexe Pentru a simplifica enunurile de mai sus, atuci cnd am conceptualizat obiectele, am spus c acestea ar trebui s-i asume un set de responsabiliti, de fapt aceste responsabiliti se vor materializa sub forma atributelor i operaiilor. O responsabilitate reprezint o obligaie, o ndatorire, a obiectelor unei clase. La nivelul cel mai abstract, atributele i operaiile corespunztoare unei clase sunt de fapt caracteristicile prin care sunt realizate sau ndeplinite responsabilitile obiectelor acesteia: un atribut reprezint o proprietate, calificat prin nume, care descrie un domeniu (range) de valori ce pot fi reinute sau stocate de ctre instanele respectivei proprieti, o operaie reprezint definiia unui serviciu care poate fi cerut oricrui obiect dintr-o clas (implementat printr-o metod intern, specific).

// Listing 1.1: Structuri OO din domeniul contabil //-------------------------------------------------------public class Cont { String cod; String denumire; // membru static static String numeOrganizatie; } //-------------------------------------------------------public class InregistrareContabila { Integer id; Integer nrOrdine; String tip; // domeniu legal: debit, credit Double suma; // membru referin Cont cont; } //-------------------------------------------------------public class OperatiuneContabila { String debit = "Debit"; String credit = "Credit"; Integer idOperatiune;

Anexe
java.util.Date dataContabilizare; // membru referin multiplicitate > 1 InregistrareContabila[] inregistrari; }

1.2.2 Instanierea i iniializarea obiectelor

Dac pentru a reprezenta, defini sau formaliza obiectele am vzut importana conceptului de clas, crearea i iniializarea obiectelor se realizeaz printr-un proces numit instanierea claselor, astfel c rezultatele acestui proces se numesc generic instane, cu alte cuvinte forma material a obiectelor ntr-un univers sau context computaional. n limbajul Java, instanierea unui obiect sau, cu alte cuvinte, obinerea unui obiect nou, implic invocarea numelui clasei folosind cuvntul-cheie new.
// Listing 1.2: Creare obiecte n mediul Java //-------------------------------------------------------public class TestCreareObiecte { public static void main(String[] args){ Cont c_411 = new Cont(); Cont c_401 = new Cont(); InregistrareContabila i1 = new InregistrareContabila(); InregistrareContabila i2 = new InregistrareContabila(); OperatiuneContabila o = new OperatiuneContabila(); } }

Odat cu instanierea unui obiect nou are loc, de regul, i iniializarea atributelor sau variabilelor de instan care formeaz starea noului obiect. Iniializarea variabilelor de instan se face difereniat funcie de: natura tipului membrilor: primitive sau non-primitive; scopul variabilelor de instan: membri statici sau non-statici.

Anexe
// Listing 1.3: Iniializare membri, statici i non-statici //-------------------------------------------------------public class TestCreareObiecte { public static void main(String[] args){ Cont.numeOrganizatie = "Gama SA"; Cont c_411 = new Cont(); c_411.cod = "411"; c_411.denumire = Clienti"; System.out.println(c_411.getClass() + : c_411 [" + c_411.cod + , + c_411.denumire + , + c_411.numeOrganizatie + ]"); Cont c_401 = new Cont(); c_401.cod = 401"; c_401.denumire = Furnizori"; System.out.println(c_401.getClass() + : c_401 [" + c_401.cod + , + c_401.denumire + , + c_401.numeOrganizatie + ]"); InregistrareContabila i1 = new InregistrareContabila(); i1.id = 1; i1.nrOrdine = 1; i1.tip = Debit"; i1.suma = 120.0; System.out.println(i1.getClass() + : i1 [" + i1.id + , + i1.tip + , + i1.suma + ]"); InregistrareContabila i2 = new InregistrareContabila(); i2.id = 2; i2.nrOrdine = 1; i2.tip = Credit"; i2.suma = 120.0; System.out.println(i2.getClass() + : i2 [" + i2.id + , + i2.tip + , + i2.suma + ]"); OperatiuneContabila o = new OperatiuneContabila(); o.idOperatiune = 1; o.dataContabilizare = new java.util.Date();// data curenta System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + ]"); } }

Anexe n Java, iniializarea implicit respect urmtoarele reguli: membrii primitivi sunt iniializai: cu 0 pentru primitive numerice, cu 0 sau spaiu pentru primitive char, cu false pentru primitive boolean; membrii referine sunt iniializai astfel nct le va fi rezervat zona de memorie necesar pentru stocarea referinelor ctre alte obiecte, fr ns a se obine i o referin efectiv, obinuindu-se s se afirme c sunt iniializai cu null.

// Listing 1.4: Iniializare membrii primitivi vs. referine //-------------------------------------------------------public class TestCreareObiecte { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont(); c_411.cod = 411"; c_411.denumire = Clienti"; System.out.println(c_411.getClass() + : c_411 [" + c_411.cod + , + c_411.denumire + , + c_411.numeOrganizatie + ]"); Cont c_5121 = new Cont(); c_5121.cod = 5121"; c_5121.denumire = Cont banca"; System.out.println(c_5121.getClass() + : c_401 [" + c_5121.cod + , + c_5121.denumire + , + c_5121.numeOrganizatie + ]"); InregistrareContabila i1 = new InregistrareContabila(); i1.id = 1; i1.nrOrdine = 1; i1.tip = Debit"; i1.suma = 120.0; System.out.println(i1.getClass() + : i1 inainte [" + i1.id + , + i1.tip + , + i1.cont + , + i1.suma + ]"); i1.cont = c_411; System.out.println(i1.getClass() + : i1 dupa [" + i1.id + , + i1.tip + , + i1.cont.cod + , + i1.suma + ]"); InregistrareContabila i2 = new InregistrareContabila();

10

Anexe
i2.id = 2; i2.nrOrdine = 1; i2.tip = Credit"; i2.suma = 120.0; System.out.println(i2.getClass() + : i2 inainte [" + i2.id + , + i2.tip + , + i2.cont + , + i2.suma + ]"); i2.cont = c_5121; System.out.println(i2.getClass() + : i2 dupa [" + i2.id + , + i2.tip + , + i2.cont.cod + , + i2.suma + ]"); OperatiuneContabila o = new OperatiuneContabila(); o.idOperatiune = 1; o.dataContabilizare = new Date(); // data curenta System.out.println(o.getClass() + ": o [" + o.idOperatiune + , + o.dataContabilizare + ]"); } } //-------------------------------------------------------Rezultat: //-------------------------------------------------------class app.model.contabilitate.Cont: c_411 [411, Clienti, Gama SA] class app.model.contabilitate.Cont: c_401 [5121, Cont banca, Gama SA] class app.model.contabilitate.InregistrareContabila: i1 inainte [1, Debit, null, 120.0] class app.model.contabilitate.InregistrareContabila: i1 dupa [1, Debit, 411, 120.0] class app.model.contabilitate.InregistrareContabila: i2 inainte [2, Credit, null, 120.0] class app.model.contabilitate.InregistrareContabila: i2 dupa [2, Credit, 5121, 120.0] class app.model.contabilitate.OperatiuneContabila: o [1, Sun Jan 10 17:22:59 EET 2010]

Iniializarea explicit a membrilor referine se refer la instanierea obiectelor n procesul de iniializare a variabilelor de instan. n mod practic, dou condiii trebuie ndeplinite: crearea unei metode-constructor care s preia drept argumente valorile ce vor fi utilizate pentru iniializarea explicit;

11

Anexe utilizarea declaraiei new n felul urmtor:

nume_var_ref = new NumeClas(argumente); // Listing 1.5: Iniializare explicit // membrii primitivi vs. referine //-------------------------------------------------------public class Cont { String cod; String denumire; static String numeOrganizatie; public Cont() { } public Cont(String cod, String denumire) { this.cod = cod; this.denumire = denumire; } } //-------------------------------------------------------public class InregistrareContabila { Integer id; Integer nrOrdine; String tip; // debit, credit Double suma; Cont cont; public InregistrareContabila() { } public InregistrareContabila(Integer id, Integer nrOrdine, String tip, Double suma, Cont cont) { this.id = id; this.nrOrdine = nrOrdine; this.tip = tip; this.suma = suma; this.cont = cont; } //--------------------------------------------------------

12

Anexe
public class OperatiuneContabila { static String debit = Debit"; static String credit = Credit"; Integer idOperatiune; Date dataContabilizare; InregistrareContabila[] inregistrari; public OperatiuneContabila() { } public OperatiuneContabila(Integer idOperatiune, Date dataContabilizare, InregistrareContabila[] inregistrari) { this.idOperatiune = idOperatiune; this.dataContabilizare = dataContabilizare; this.inregistrari = inregistrari; } }

//-------------------------------------------------------public class TestCreareObiecte2 { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont("411", Clienti"); System.out.println(c_411.getClass() + : c_411 [" + c_411.cod + , + c_411.denumire + , + c_411.numeOrganizatie + ]"); Cont c_5121 = new Cont("5121", Cont banca"); System.out.println(c_5121.getClass() + : c_401 [" + c_5121.cod + , + c_5121.denumire + , + c_5121.numeOrganizatie + ]"); InregistrareContabila i1 = new InregistrareContabila(1, 1, Debit", 120.0, c_411); System.out.println(i1.getClass() + : i1 [" + i1.id + , + i1.tip + , + i1.cont.cod + , + i1.suma + ]"); InregistrareContabila i2 = new InregistrareContabila(1, 1, Credit", 120.0, c_5121); System.out.println(i2.getClass() + : i2 [" +

13

Anexe
i2.id + , + i2.tip + , + i2.cont.cod + , + i2.suma + ]"); OperatiuneContabila o = new OperatiuneContabila(1, new Date(), null); System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + ]"); } }

n structura unui obiect, din punct de vedere conceptual, un membruvariabil de instan este caracterizat i prin multiplicitate (pe lng nume i tip, aa cum am artat mai sus). Practic vorbind, n cazul limbajului Java, atunci cnd un membru-variabil de instan trebuie s gestioneze mai multe valori de acelai tip, ceea ce nseamn c din punct de vedere conceptual este vorba de o multiplicitate > 1, atunci, varianta cea mai direct presupune c acel membru va fi de fapt de tip array.

Folosirea tablourilor pentru membri cu mutiplicitate > 1

Declararea unui membru de tip array n limbajul Java presupune adugarea, fie la numele membrului, fie la tipul acestuia, a simbolurilor specifice [ i ] :
NumeTip [] numeTablou; // sau NumeTip numeTablou[];

n fapt, un tablou este o instan, un obiect, provenit dintr-o clas care permite gestionarea indexat a mai multor valori de acelai tip. Pentru aflarea dimensiunii (numrului de elemente) tablourile prezint proprietatea intrinsec length. Procesul de iniializare a unui tablou presupune urmtoarele etape: iniializarea tabloului n sine - n aceast etap va fi specificat numrul de elemente care vor forma tabloul, i iniializarea elementelor care formeaz tabloul (sau rubricilor tabloului).
// Listing 1.5: Exemplu iniializare tablou //-------------------------------------------------------public class TestCreareObiecte3 { public static void main(String[] args){

14

Anexe
Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont("411", Clienti"); Cont c_5121 = new Cont("5121", Cont banca"); // Declarare tablou InregistrareContabila[] inregistrariContabile; // Iniializare tablou inregistrariContabile = new InregistrareContabila[2]; // Iniializare explicit a elementelor inregistrariContabile[0] = new InregistrareContabila(1, 1, Debit", 120.0, c_411); inregistrariContabile[1] = new InregistrareContabila(1, 1, Credit", 120.0, c_5121); OperatiuneContabila o = new OperatiuneContabila(1, new Date(), inregistrariContabile); System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + , + o.inregistrari.length + ]"); } } //-------------------------------------------------------Rezultat: //-------------------------------------------------------class app.model.contabilitate.OperatiuneContabila: o [1, Sun Jan 10 17:41:24 EET 2010, 2]

Sintaxa limbajului Java, permite reprezentarea procesului de iniializare n dou moduri: 1) iniializarea separat a tabloului i a elementelor, vezi exemplul de mai sus; 2) iniializarea n aceeai instruciune a tabloului i elementelor, vezi exemplul care urmeaz.
// Listing 1.6: Rafinare iniializare tablou //-------------Varianta 1 ----------------------------public class TestCreareObiecte4 { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA";

15

Anexe
Cont c_411 = new Cont("411", Clienti"); Cont c_5121 = new Cont("5121", Cont banca"); InregistrareContabila[] inregistrariContabile = { new InregistrareContabila(1, 1,"Debit", 120.0, c_411), new InregistrareContabila(2, 1,"Credit", 120.0, c_5121) }; OperatiuneContabila o = new OperatiuneContabila(1, new Date(), inregistrariContabile); System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + , + o.inregistrari.length + ]"); // parcurgere elemente tablou for (InregistrareContabila i : o.inregistrari){ System.out.println(i.getClass() + : i [" + i.id + , + i.tip + , + i.cont.cod + , + i.suma + ]"); } } } //-------------Varianta 2 ----------------------------public class TestCreareObiecte5 { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont("411", Clienti"); Cont c_5121 = new Cont("5121", Cont banca"); OperatiuneContabila o = new OperatiuneContabila(1, new Date(), new InregistrareContabila[]{ new InregistrareContabila(1, 1,"Debit", 120.0, c_411), new InregistrareContabila(2, 1, "Credit", 120.0, c_5121) } ); System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + , +

16

Anexe
o.inregistrari.length + ]"); // parcurgere elemente tablou for (int i = 0; i < o.inregistrari.length; i++){ System.out.println(o.inregistrari[i].getClass() + ": i" + i + [" + o.inregistrari[i].id + ", + o.inregistrari[i].tip + , + o.inregistrari[i].cont.cod + ", + o.inregistrari[i].suma + ]"); } } }

Folosirea coleciilor pentru membri cu mutiplicitate > 1

n limbajul Java, de altfel i n alte limbaje consacrate orientate obiect, tablourile au avantajul integrrii lor n sintaxa limbajului. Ele au ns i dezavantaje destul de importante, dintre care putem sublinia cel puin imposibilitatea re-dimesionrii dinamice. Aceste dezavantaje au fost depite, ntr-un anume fel, folosind coleciile pentru gestiunea comun a unui grup de valori, primitive sau referine, n locul tablourilor. De exemplu, colecia List, implementat concret prin clasa ArrayList, are urmtoarele caracteristici marcate printr-un set de operaii specifice: posibilitatea aflrii numrului de elemente din list: size(); posibilitatea verificrii iniializrii cu elemente concrete a listei: isEmpty(); posibilitatea accessului la elemente individuale: o obinerea elementului de pe o poziie dat, get(indexNN); o stocarea referinei unui obiect ca un element situat pe o poziie dat, set(indexNN, element); o tergerea din colecie a referinei unui obiect de la o poziie dat, remove(indexNN); o poziia concret n colecie a referinei unui obiect dat, indexOf(element); conversie ntr-o structur clasic de tip tablou: o toArray(). Structura de control repetitiv necesar parcurgerii elementelor unei colecii provine din clasica structur for adaptat specific astfel:
for(Tip numeVarIterati : numeList) {... ...}

17

Anexe
// Listing 1.7: Exemplu iniializare list //-------------------------------------------------------public class OperatiuneContabila { static String debit = Debit"; static String credit = Credit"; Integer idOperatiune; Date dataContabilizare; List<InregistrareContabila> inregistrari = new ArrayList<InregistrareContabila>(); // fata de: InregistrareContabila[] inregistrari public OperatiuneContabila() { } public OperatiuneContabila(Integer idOperatiune, Date dataContabilizare, List<InregistrareContabila> inregistrari) { this.idOperatiune = idOperatiune; this.dataContabilizare = dataContabilizare; this.inregistrari = inregistrari; } } //-------------------------------------------------------public class TestCreareObiecte_6 { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont("411", Clienti"); Cont c_5121 = new Cont("5121", Cont banca"); List<InregistrareContabila> inregistratiContabile = new ArrayList<InregistrareContabila>(); inregistratiContabile.add(new InregistrareContabila(1, 1,"Debit", 120.0, c_411)); inregistratiContabile.add(new InregistrareContabila(2, 1,"Credit", 120.0, c_5121)); OperatiuneContabila o = new OperatiuneContabila(1, new Date(),inregistratiContabile); System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare +

18

Anexe
", + o.inregistrari.size() + ]"); for (InregistrareContabila i : o.inregistrari){ System.out.println(i.getClass() + : i [" + i.id + , + i.tip + , + i.cont.cod + , + i.suma + ]"); } } }

19

Anexe

1.3 Interaciunea cu i ntre obiecte

n continuare vom ncerca s lmurim rolul obiectelor n execuia aplicaiilor, mai exact modul n care se efectueaz apelul sau invocarea obiectelor.

1.3.1 Invocarea i accesarea obiectelor. Structuri de date orientate obiect

n general, execuia unei aplicaii reprezint set de apeluri de funcii i proceduri. Execuia unei aplicaii cu obiecte poate fi vzut ca un set de interaciuni ntre un grup/comunitate de obiecte. Prin interaciune se nelege de fapt apelul (sincron sau asicron) al operaiilor asociate obiectelor. Invocarea operaiilor se realizeaz prin adresare ctre (prin intermediul) obiectele (obiectelor) de care aparin. Concret, n cazul aplicaiilor scrise n limbajul Java invocarea obiectelor se circumscrie n mare sintaxei, aa-zise cu punct:
sintaxa cu punct: obiect.operaie (list argumente)

Invocarea aceleai operaii ctre obiecte distincte poate conduce la rezultate distincte: execuia operaiei se face n contextul de stare distinct, propriu fiecrui obiect. Invocarea operaiilor presupune anumite pre-condiii: mai nti trebuie s existe obiectele: obiectele trebuie instaniate; obiectele trebuie s fie adresabile (s poat fi accesate referinele lor n contextul din care vor fi invocate); obiectele trebuie s prezinte operaii invocabile (vizibile).

1.3.2 Operaii, parametri, metode i variabile interne

Dup cum am artat deja, semntura operaiilor, cel puin n cazul limbajului Java, presupune urmtoarele specificaii privind: numele i tipul returnat; specificatori de vizibilitate; parametrizarea. 20

Anexe Metodele reprezint formal blocuri de instruciuni care: pe de o parte descriu algoritmul despre cum anume concret sau funcional, se comport un obiect invocat prin numele unei operaii; pe de alt parte sunt executate ca urmare a invocrii operaiilor crora i este ataate ca specificaii de implemenare.

De multe ori termenii de operaie i metod sunt folosii interschimbabil. Cu preponderen n contextul claselor se folosete termenul metode, iar n contextul interfeelor se folosete termenul operaii. Acetia reprezint totui concepte diferite, operaia reprezint doar o specificaie de interaciune, formatul mesajelor de interaciune, iar metodele reprezint formele concrete de re-aciune a obiectelor la aceste mesaje. Pe scurt, spunem c metodele reprezint implementarea operaiilor. Structurilele specifice care pot forma blocul de instruciuni ce concretizeaz o metod constau n: structuri de date: variabile interne; invocarea variabilelor de instan, declarate la nivelul clasei; parametri; structuri de control: alternative, simple sau generalizate; repetitive; recursive.

// Listing 1.8: Sintaxa structurilor specifice limbajului Java if (<expr-boolean>){ <bloc de instruciuni> } else if { <bloc de instruciuni> } else { <bloc de instruciuni> }// end if ------------------------------------switch <expresie evaluabil la valori int sau Integer>{ case <valoare int/Integer> : {

21

Anexe
<bloc de instruciuni> } break; case <valoare int/Integer> : { <bloc de instruciuni> } break; // in lips va continua i evaluarea // celorlalte ramuri introduse prin valori int/Integer .. ... ... default <valoare int/Integer> : { <bloc de instruciuni> } break; }// end switch ------------------------------------while (<expr-boolean>) { <bloc de instruciuni> break; // prsire bloc while continue; // salt la iteraia urmtoare <bloc de instruciuni> }// end while ------------------------------------for (<iniializare increment>; <expr-boolean>; <expr-incrementare>){ <bloc de instruciuni> break; continue; <bloc de instruciuni> }// end for simplu ------------------------------------for (<iniializare var parcurgere elemente> : <nume tablou sau colecie>){ <bloc de instruciuni> break; continue; <bloc de instruciuni> }// end for parcurgere colecie ------------------------

Un tip de metode speciale, care nu sunt asociate n mod concret unei operaii explicite, al crui nume este de fapt numele clasei, sunt metodele constructor. Nefiind reprezentarea unei operaii, care eventual ar putea face parte din specificaia unei interfee, invocarea unui constructor se face prin cuvntul cheie new i numele clasei.

22

Anexe
// Listing 1.9: Exemplu iniializare list //------------------------------------------------------public class ServiciuOperatiuni { //declaratie operatie public Double getSold(OperatiuneContabila o) { // start metoda implementare operaie return getDebit(o) - getCredit(o); } // sfrit metoda implementare operaie public Double getDebit(OperatiuneContabila o //parametru ){ Double debit = 0.0; // variabila intern for (InregistrareContabila i: o.inregistrari){ if (i.tip == OperatiuneContabila.debit) debit += i.suma; } return debit; } public Double getCredit(OperatiuneContabila o){ Double credit = 0.0; for (InregistrareContabila i: o.inregistrari){ if (i.tip == OperatiuneContabila.debit) credit += i.suma; } return credit; } } //-------------------------------------------------------public class TestCreareObiecte_7 { public static void main(String[] args){ Cont.numeOrganizatie = Gama SA"; Cont c_411 = new Cont("411", Clienti"); Cont c_5121 = new Cont("5121", Cont banca"); List<InregistrareContabila> inregistratiContabile = new ArrayList<InregistrareContabila>(); inregistratiContabile.add( new InregistrareContabila(1, 1, "Debit", 120.0, c_411)); inregistratiContabile.add( new InregistrareContabila(2, 1, "Credit", 120.0, c_5121));

23

Anexe
OperatiuneContabila o = new OperatiuneContabila(1, new Date(), inregistratiContabile); ServiciuOperatiuni s = new ServiciuOperatiuni(); Double sold = s.getSold(o); // invocare operatie System.out.println(o.getClass() + : o [" + o.idOperatiune + , + o.dataContabilizare + ", + sold = + sold + ]"); for (InregistrareContabila i : o.inregistrari){ System.out.println(i.getClass() + : i [" + i.id + , + i.tip + , + i.cont.cod + , + i.suma + ]"); } } } //-------------------------------------------------------Rezultat //-------------------------------------------------------class app.model.contabilitate.OperatiuneContabila: o [1, Sun Jan 10 18:27:19 EET 2010, sold = 0.0] class app.model.contabilitate.InregistrareContabila: i [1, Debit, 411, 120.0] class app.model.contabilitate.InregistrareContabila: i [2, Credit, 5121, 120.0]

24