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

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

Limbajul unificat de
modelare

Identitate
Stare

Atribut

Comportament
Interaciuni

Limbaje de
programare
orientate obiect

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