Obiecte in Pascal

Modelul de date orientate obiect

Spre deosebire de programarea clasica - programarea functionala, in programarea orientata obiect (OOP) accentul se pune asupra datelor si legaturilor existente intre acestea, ca elemente prin care se modeleaza obiectele lumii reale.

Aparitia OOP poate fi datata la sfarsitul anilor ’60, odata cu elaborarea unui limbaj destinat tratarii problemelor de simulare, numit SimulaI (1966). Este primul limbaj care incorporeaza intr-o singura entitate datele si metodele asociate. Conceptele de clasa si obiect sunt clarificate apoi in limbajul SimulaII (1973). Dezvoltarea OOP este marcata puternic de crearea versiunilor succesive ale limbajului Smaltalk (1972, 1976, 1980) care introduce, printre altele, conceptul de mostenire.

Obiecte

Obiectul reprezinta modelul informational al unei entitati reale care poseda, la un anumit nivel, o multime de proprietati si are, in timp, un anumit comportament (relativ la relatiile sale cu alte obiecte din acelasi mediu). Un obiect este identificat prin nume si contine o multime de date, care descriu proprietatile obiectului si subrutine, care definesc comportamentul acestuia.

Functie de proprietatile comune si comportamentul similar al entitatilor pe care le exprima, obiectele pot f††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††††† ††††††††††††††††††n, denumit Ccomplexe:

Din punct de vedere declarativ, o clasa poate fi considerata ca un tip special de date, iar obiectele sale ca date de acest tip.

Datele, care reprezinta proprietatile obiectelor, se numesc atribute si sunt de un anumit tip (intregi, reale, booleene etc). Procedurile si functiile, care definesc comportamentul obiectelor, se numesc metode. Atributele si metodele constituie membrii clasei, identificabili prin nume. Pentru a adresa un anumit membru al unui obiect se utilizeaza referirea nume obiect.nume membru

De exemplu, a.p reala desemneaza valoarea primului atribut al obiectului a din clasa Ccomplexe, iar a.Conjugat(b) refera metoda Conjugat a obiectului a pentru a produce obiectul rezultat b=

Despre o metoda apelata cu un anumit obiect se spune ca se executa in context obiect, iar obiectul respectiv se numeste obiect curent. Apelul propriu-zis este considerat ca o trimitere de mesaj spre obiectul curent, iar executia metodei reprezinta raspunsul pe care obiectul curent il ofera acelui mesaj.

Faptul ca o metoda se executa in contextul obiectului curent inseamna ca are, implicit, acces la atributele si celelalte metode ale acestuia. Pentru alte obiecte (din aceeasi clasa sau din alta), metoda trebuie referita corespunzator. Pentru simplificarea scrierii, referirea la membrii obiectului curent se face fara calificare.

Exemplu

Descrierea in pseudocod metodelor Conjugat, Suma si Modul din clasa Ccomplexe poate fi facuta astfel:

procedure Conjugat(b);

begin

b.p_reala:=p_reala;

b.p_imaginara:=-p_imaginara;

end;

procedure Suma(b,c);

begin

c.p_reala:=p_reala+b.p_reala;

c.p_imaginara:=-p_imaginara+b.p_imaginara;

end;

function Modul:real;

begin

Modul:=sqrt(sqr(p_reala)+sqr(p_imaginra));

end;

Cum o clasa este un tip de data, in definirea unei clase B se pot declara atribute de tip A, unde A este, la randul ei, o clasa. Mai mult, o clasa A poate defini atribute de tip A. Printre argumentele unei metode pot fi si argumente de tip clasa.

Exemple

1.

2. Pentru clasa CComplexe, argumentele procedurilor sunt de tip CComplexe.

In multe situatii si functie de context, printre metodele unei clase poate sa fie definita si metode de tip constructor si sau destructor. Un constructor este o metoda ce creeaza un obiect, in sensul ca ii aloca memorie si sau initializeaza atributele acestuia. Destructorul este o metoda care incheie ciclul de viata al unui obiect, eliberand spatiul ocupat de acesta.

1.2. Incapsularea

Acest concept exprima opacitatea obiectelor cu privire la structura lor interna si la modul de implementare a metodelor. Ea este legata de securitatea programarii si ofera un mecanism de control al accesului la starea si functionalitatea obiectelor. O clasa trebuie sa aiba membrii impartiti in doua sectiuni: partea publica si partea privata. Partea publica este constituita din membrii pe care fiecare obiect al clasei ii pune la dispozitie altor obiecte. Ea reprezinta interfata obiectelor cu lumea exterioara si depinde de proiectantul clasei. La limita, interfata este compusa numai din metode. Daca se doreste ca utilizatorii obiectelor clasei sa poata prelua si sau stabili valorile unor atribute ale acestora, interfata trebuie sa prevada metode specifice, numite accesorii. Partea privata cuprinde acei membri care servesc exclusiv obiectelor clasei respective. De regula, in aceasta parte se include atribute si metode care faciliteaza implementarea interfetei.

Exemplu

Clasa CComplexe poate fi partajata astfel:

Observatie: Incapsularea permite ca utilizatorul metodelor sa nu cunoasca codul lor si, deci, sa nu fie dependent in utilizare de schimbarea acestuia.

1.3. Mostenirea

Conceptul de mostenire este elementul definitoriu al OOP si reprezinta modalitatea de construire a relatiilor dintre diferitele clase utilizate. Mostenirea permite construirea, pe baza claselor existente, numite clase de baza, a unei noi clase, numita clasa derivata. Daca in procesul derivarii se porneste de la o singura clasa de baza, atunci mostenirea este simpla; altfel, mostenirea este multipla. In limbajul Pascal este implementata numai mostenirea simpla.

Se spune ca o clasa D mosteneste o clasa B, daca obiectele lui D contin toate atributele clasei B si au acces la toate metodele definite de B. In plus,

D poate defini alte atribute si metode;

D poate redefini metode ale clasei de baza;

Metodele noi si cele mostenite au acces la toate atributele dobandite si definite.

Exemplu

B

D

Clasa Circle mosteneste clasa Point. Atributele unui obiect al clasei derivate sunt: X, Y mostenite (reprezinta centru cercului) si Raza, atribut propriu. Functia Distanta din clasa Point este mostenita si calculeaza distanta dintre doua cercuri, ca distanta dintre centrele lor. Functia Arie este proprie clasei Circle. Procedura Deseneaza este redefinita, corespunzator codului diferit pe care trebuie sa-l aiba.

In cazul unei multimi de clase, mostenirea simpla induce o structura de arbore ierarhic, numit arbore de mostenire.

Observatii

Daca se aduc modificari clasei de baza nu este necesara modificarea clasei derivate.

Mostenirea permite, prin procesul de derivare, specializarea si imbogatirea clasei de baza.

Mostenirea este mecanismul prin care se asigura reutilizarea codului, diminuand astfel efortul de programare.

1.4. Polimorfismul

Polimorfismul este un concept mai vechi al programarii si este prezent in limbajele cu tip si in cele extinse in modelul orientat pe date, implementat prin limbajele cu tip, in care clasa reprezinta tipl de date obiect.

In limbajele de programare cu tip, polimorfismul exprima capacitatea limbajului de a exprima comportamentul unei proceduri independent de natura parametrilor sai. De exemplu, o procedura de sortare a unui sir de date este polimorfa daca poate fi descrisa independent de tipul acestor valori. In general, exista trei tipuri de polimorfism:

Polimorfism ad-hoc (sau supraincarcare): proceduri cu acelasi nume, dar cu numar si/sau tipuri de parametridiferiti. In limbajul Pascal acest tip de polimorfism este implementat doar pentru operatorii limbajului.

Polimorfism de incluziune : se bazeaza pe o relatie de ordine partiala intre tipurile de date. Daca AB si exista o procedura ce are ca argument un parametru de tip B, atunci acesteia i se poate pasa ca parametru corespunzator unul de tip A. In limbajul Pascal este aplicabil numai rutinelor de control.

Polimorfism parametric: definirea unui model de rutina in care chiar tipurilor argumentelor sunt parametri. Acest tip de polimorfism se numeste si genericitate si presupune ca procedura se genereaza pentru fiecare tip transmis la apel ca parametru.

In limbajele orientate pe obiecte, primele doua tipuri de polimorfism au urmatoarele extensii:

Polimorfism ad-hoc: posibilitatea de a defini, in cadrul a doua clase distincte, metode cu acelasi nume, cu parametri distinti sau identici (acelasi lucru se intampla si in cazul relatiei de mostenire, dar, in cazul parametrilor identici este vorba despre redefinire si nu supraincarcare).

Polimorfism de incluziune (de mostenire): este legat de relatia de mostenire, astfel. Daca clasa D mosteneste clasa B (direct sau prin parinti), atunci DB. In aceste conditii orice metoda din clasa B este aplicabila obiectelor din clasa D si orice metoda care are definit un parametru de tip B poate primi ca argument actual un obiect de calsa D.

1.5. Legarea statica si dinamica a metodelor

Legarea statica a metodelor se regaseste atat in limbajele clasice, cat si in cele orientate obiect. Compilatorul poate determina care metoda din ce clasa este efectiv apelata intr-un anumit context si poate genera codul de apel corespunzator.

Datorita polimorfismului si lucrului cu pointeri in limbajele orientate obiect, un obiect din clasa parinte, desemnat indirect (prin referinta) i se poate atribui un obiect fiu. Daca se apeleaza o metoda polimorfica in acest context, nu se stie la momentul compilarii daca ea trebuie apelata in varianta clasei de baza sau a celei derivate. Compilatorul va genera un cod care, la momentu executiei, va testa tipul efectiv al obiectului si, dupa caz, va realiza legarea metodei adecvate. In acest caz legarea este dinamica.

2. Clase si obiecte in Pascal

Specificarea claselor si utilizarea obiectelor

Declararea structurii unei clase, ca tip, se face in sectiunea type sub forma generala:

type

referinta_clasa=^nume_clasa;

nume_clasa=object

atr1:tip1; Partea publica

. . . ..

atrn:tipn;

metoda1;

. . .

metodam;

end;

Definirea metodelor consta in construirea corpurilor subprogramelor corespunzatoare. Prin identificarea clasei din care face parte metoda, numele metodei va fi prefixat cu numele clasei.

Cum, prin definitie, clasele trebuie sa fie entitati reutilizabile, acestea se incapsuleaza intr-o unitate. Declararea claselor se face in sectiunea interface, iar definirea metodelor in sectiunea implementation. Se recomanda, pentru claritatea scrierii, ca fiecare clasa sa corespunda unui unit.

In continuare va fi prezentat unit-ul care contine descrierea clasei CComplexe.

unit complex;

interface

type

ccomplexe=object

function get_r:real;

function get_im:real;

procedure init(r,i:real);

procedure conjugat(var b:ccomplexe);

function modul:real;

procedure suma(b:ccomplexe;var c:ccomplexe);

procedure dif(b:ccomplexe;var c:ccomplexe);

procedure produs(b:ccomplexe;var c:ccomplexe);

procedure raport(b:ccomplexe;var c:ccomplexe;var p:boolean);

private

p_reala,p_imaginara:real;

procedure minus(var b:ccomplexe);

function zero:boolean;

end;

implementation

procedure ccomplexe.conjugat(var b:ccomplexe);

begin

b.p_reala:=p_reala;

b.p_imaginara:=-p_imaginara;

end;

function ccomplexe.get_r:real;

begin

get_r:=p_reala;

end;

function ccomplexe.get_im:real;

begin

get_im:=p_imaginara;

end;

procedure ccomplexe.init(r,i:real);

begin

p_reala:=r;

p_imaginara:=i;

end;

function ccomplexe.modul:real;

begin

modul:=sqrt(p_reala*p_reala+p_imaginara*p_imaginara);

end;

procedure ccomplexe.suma(b:ccomplexe;var c:ccomplexe);

begin

c.p_reala:=b.p_reala+p_reala;

c.p_imaginara:=b.p_imaginara+p_imaginara;

end;

procedure ccomplexe.minus(var b:ccomplexe);

begin

b.p_reala:=-p_reala;

b.p_imaginara:=-p_imaginara;

end;

procedure ccomplexe.dif(b:ccomplexe;var c:ccomplexe);

var d:ccomplexe;

begin

b.minus(d);

suma(d,c);

end;

procedure ccomplexe.produs(b:ccomplexe;var c:ccomplexe);

begin

c.p_reala:=b.p_reala*p_reala-b.p_imaginara*p_imaginara;;

c.p_imaginara:=b.p_reala*p_imaginara+b.p_imaginara*p_reala;

end;

function ccomplexe.zero:boolean;

begin

zero:=(p_reala=0)and(p_imaginara=0);

end;

procedure ccomplexe.raport(b:ccomplexe;var c:ccomplexe;var p:boolean);

var

d:ccomplexe;

r:real;

begin

if not b.zero then

begin

r:=b.modul;

b.conjugat(d);

produs(d,c);

c.p_reala:=c.p_reala/sqr(r);

c.p_imaginara:=c.p_imaginara/sqr(r);

p:=true

end

else p:=false;

end;

end.