Capitolul VI
Obiecte Java

6.1 Declaraţia unei noi clase de obiecte

Pasul 1: Stabilirea conceptului reprezentat de clasa de obiecte
Pasul 2: Stabilirea numelui clasei de obiecte
Pasul 3: Stabilirea superclasei
Pasul 4: Stabilirea interfeţelor pe care le respectă clasa
Pasul 5: Stabilirea modificatorilor clasei
Pasul 6: Scrierea corpului declaraţiei
Stop: Forma generală a unei declaraţii de clasă

6.2 Variabilele unei clase

6.2.1 Modificatori
6.2.2 Protecţie
6.2.3 Accesarea unei variabile
6.2.4 Vizibilitate
6.2.5 Variabile predefinite: this şi super

6.3 Metodele unei clase

6.3.1 Declararea metodelor

6.3.1.1 Numele şi parametrii metodelor
6.3.1.2 Modificatori de metode

6.3.1.2.1 Metode statice
6.3.1.2.2 Metode abstracte
6.3.1.2.3 Metode finale
6.3.1.2.4 Metode native
6.3.1.2.5 Metode sincronizate

6.3.1.3 Protejarea metodelor

6.3.2 Clauze throws
6.3.3 Apelul metodelor
6.3.4 Valoarea de retur a unei metode
6.3.5 Vizibilitate

6.4 Iniţializatori statici
6.5 Constructori şi finalizatori

6.5.1 constructori
6.5.2 Finalizatori
6.5.3 Crearea instanţelor

6.6 Derivarea claselor
6.7 Interfeţe

În primul rând să observăm că, atunci când scriem programe în Java nu facem altceva decât să definim noi şi noi clase de obiecte. Dintre acestea, unele vor reprezenta însăşi aplicaţia noastră în timp ce altele vor fi necesare pentru rezolvarea problemei la care lucrăm. Ulterior, atunci când dorim să lansăm aplicaţia în execuţie nu va trebui decât să instanţiem un obiect reprezentând aplicaţia în sine şi să apelăm o metodă de pornire definită de către aplicaţie, metodă care de obicei are un nume şi un set de parametri bine fixate. Totuşi, numele acestei metode depinde de contextul în care este lansată aplicaţia noastră.

Această abordare a construcţiei unei aplicaţii ne spune printre altele că vom putea lansa oricâte instanţe ale aplicaţiei noastre dorim, pentru că fiecare dintre acestea va reprezenta un obiect în memorie având propriile lui valori pentru variabile. Execuţia instanţelor diferite ale aplicaţiei va urma desigur căi diferite în funcţie de interacţiunea fiecăreia cu un utilizator, eventual acelaşi, şi în funcţie de unii parametri pe care îi putem defini în momentul creării fiecărei instanţe.

6.1 Declaraţia unei noi clase de obiecte

Pasul 1: Stabilirea conceptului reprezentat de clasa de obiecte

Să vedem ce trebuie să definim atunci când dorim să creăm o nouă clasă de obiecte. În primul rând trebuie să stabilim care este conceptul care este reprezentat de către noua clasă de obiecte şi să definim informaţiile memorate în obiect şi modul de utilizare a acestuia. Acest pas este cel mai important din tot procesul de definire al unei noi clase de obiecte. Este necesar să încercaţi să respectaţi două reguli oarecum antagonice. Una dintre ele spune că nu trebuiesc create mai multe clase de obiecte decât este nevoie, pentru a nu face dificilă înţelegerea modului de lucru al aplicaţiei la care lucraţi. Cea de-a doua regulă spune că nu este bine să mixaţi într-un singur obiect funcţionalităţi care nu au nimic în comun, creând astfel clase care corespund la două concepte diferite.

Medierea celor două reguli nu este întotdeauna foarte uşoară. Oricum, vă va fi mai uşor dacă păstraţi în minte faptul că fiecare clasă pe care o definiţi trebuie să corespundă unui concept real bine definit, necesar la rezolvarea problemei la care lucraţi. Şi mai păstraţi în minte şi faptul că este inutil să lucraţi cu concepte foarte generale atunci când aplicaţia dumneavoastră nu are nevoie decât de o particularizare a acestora. Riscaţi să pierdeţi controlul dezvoltării acestor clase de obiecte prea generale şi să îngreunaţi dezvoltarea aplicaţiei.

Pasul 2: Stabilirea numelui clasei de obiecte

După ce aţi stabilit exact ce doriţi de la noua clasă de obiecte, sunteţi în măsură să găsiţi un nume pentru noua clasă, nume care trebuie să urmeze regulile de construcţie ale identificatorilor limbajului Java definite în capitolul anterior.

Stabilirea unui nume potrivit pentru o nouă clasă nu este întotdeauna un lucru foarte uşor. Problema este că acest nume nu trebuie să fie exagerat de lung dar trebuie să exprime suficient de bine destinaţia clasei. Regulile de denumire ale claselor sunt rezultatul experienţei fiecăruia sau al unor convenţii de numire stabilite anterior. De obicei, numele de clase este bine să înceapă cu o literă majusculă. Dacă numele clasei conţine în interior mai multe cuvinte, aceste cuvinte trebuie de asemenea începute cu literă majusculă. Restul caracterelor vor fi litere minuscule.

De exemplu, dacă dorim să definim o clasă de obiecte care implementează conceptul de motor Otto vom folosi un nume ca MotorOtto pentru noua clasă ce trebuie creată. La fel, vom defini clasa MotorDiesel sau MotorCuReacţie. Dacă însă avem nevoie să definim o clasă separată pentru un motor Otto cu cilindri în V şi carburator, denumirea clasei ca MotorOttoCuCilindriÎnVŞiCarburator nu este poate cea mai bună soluţie. Poate că în acest caz este preferabilă o prescurtare de forma MotorOttoVC. Desigur, acestea sunt doar câteva remarci la adresa acestei probleme şi este în continuare necesar ca în timp să vă creaţi propria convenţie de denumire a claselor pe care le creaţi.

Pasul 3: Stabilirea superclasei

În cazul în care aţi definit deja o parte din funcţionalitatea de care aveţi nevoie într-o altă superclasă, puteţi să derivaţi noua clasă de obiecte din clasa deja existentă. Dacă nu există o astfel de clasă, noua clasă va fi automat derivată din clasa de obiecte predefinită numită Object. În Java, clasa Object este superclasă direct sau indirect pentru orice altă clasă de obiecte definită de utilizator.

Alegerea superclasei din care derivaţi noua clasă de obiecte este foarte importantă pentru că vă ajută să refolosiţi codul deja existent. Totuşi, nu alegeţi cu uşurinţă superclasa unui obiect pentru că astfel puteţi încărca obiectele cu o funcţionalitate inutilă, existentă în superclasă. Dacă nu există o clasă care să vă ofere doar funcţionalitatea de care aveţi nevoie, este preferabil să derivaţi noua clasă direct din clasa Object şi să apelaţi indirect funcţionalitatea pe care o doriţi.

Pasul 4: Stabilirea interfeţelor pe care le respectă clasa

Stabilirea acestor interfeţe are dublu scop. În primul rând ele instruiesc compilatorul să verifice dacă noua clasă respectă cu adevărat toate interfeţele pe care le-a declarat, cu alte cuvinte defineşte toate metodele declarate în aceste interfeţe. A doua finalitate este aceea de a permite compilatorului să folosească instanţele noii clase oriunde aplicaţia declară că este nevoie de un obiect care implementează interfeţele declarate.

O clasă poate să implementeze mai multe interfeţe sau niciuna.

Pasul 5: Stabilirea modificatorilor clasei

În unele cazuri trebuie să oferim compilatorului informaţii suplimentare relative la modul în care vom folosi clasa nou creată pentru ca acesta să poată executa verificări suplimentare asupra descrierii clasei. În acest scop, putem defini o clasă ca fiind abstractă, finală sau publică folosindu-ne de o serie de cuvinte rezervate numite modificatori. Modificatorii pentru tipurile de clase de mai sus sunt respectiv: abstract, final şi public.

În cazul în care declarăm o clasă de obiecte ca fiind abstractă, compilatorul va interzice instanţierea acestei clase. Dacă o clasă este declarată finală, compilatorul va avea grijă să nu putem deriva noi subclase din această clasă. În cazul în care declarăm în acelaşi timp o clasă de obiecte ca fiind abstractă şi finală, eroarea va fi semnalată încă din timpul compilării pentru că cei doi modificatori se exclud.

Pentru ca o clasă să poată fi folosită şi în exteriorul contextului în care a fost declarată ea trebuie să fie declarată publică. Mai mult despre acest aspect în paragraful referitor la structura programelor. Până atunci, să spunem că orice clasă de obiecte care va fi instanţiată ca o aplicaţie trebuie declarată publică.

Pasul 6: Scrierea corpului declaraţiei

În sfârşit, după ce toţi ceilalţi paşi au fost efectuaţi, putem trece la scrierea corpului declaraţiei de clasă. În principal, aici vom descrie variabilele clasei împreună cu metodele care lucrează cu acestea. Tot aici putem preciza şi gradele de protejare pentru fiecare dintre elementele declaraţiei. Uneori numim variabilele şi metodele unei clase la un loc ca fiind câmpurile clasei. Subcapitolele următoare vor descrie în amănunt corpul unei declaraţii.

Stop: Forma generală a unei declaraţii de clasă

Sintaxa exactă de declarare a unei clase arată în felul următor:

{ abstract | final | public }* class NumeClasă

[ extends NumeSuperclasă ]

[ implements NumeInterfaţă [ , NumeInterfaţă ]* ]

{ [ CâmpClasă ]* }

6.2 Variabilele unei clase

În interiorul claselor se pot declara variabile. Aceste variabile sunt specifice clasei respective. Fiecare dintre ele trebuie să aibă un tip, un nume şi poate avea iniţializatori. În afară de aceste elemente, pe care le-am prezentat deja în secţiunea în care am prezentat variabilele, variabilele definite în interiorul unei clase pot avea definiţi o serie de modificatori care alterează comportarea variabilei în interiorul clasei, şi o specificaţie de protecţie care defineşte cine are dreptul să acceseze variabila respectivă.

6.2.1 Modificatori

Modificatorii sunt cuvinte rezervate Java care precizează sensul unei declaraţii. Iată lista acestora:

static
final
transient
volatile

Dintre aceştia, transient nu este utilizat în versiunea curentă a limbajului Java. Pe viitor va fi folosit pentru a specifica variabile care nu conţin informaţii care trebuie să rămână persistente la terminarea programului.

Modificatorul volatile specifică faptul că variabila respectivă poate fi modificată asincron cu rularea aplicaţiei. În aceste cazuri, compilatorul trebuie să-şi ia măsuri suplimentare în cazul generării şi optimizării codului care se adresează acestei variabile.

Modificatorul final este folosit pentru a specifica o variabilă a cărei valoare nu poate fi modificată. Variabila respectivă trebuie să primească o valoare de iniţializare chiar în momentul declaraţiei. Altfel, ea nu va mai putea fi iniţializată în viitor. Orice încercare ulterioară de a seta valori la această variabilă va fi semnalată ca eroare de compilare.

Modificatorul static este folosit pentru a specifica faptul că variabila are o singură valoare comună tuturor instanţelor clasei în care este declarată. Modificarea valorii acestei variabile din interiorul unui obiect face ca modificarea să fie vizibilă din celelalte obiecte. Variabilele statice sunt iniţializate la încărcarea codului specific unei clase şi există chiar şi dacă nu există nici o instanţă a clasei respective. Din această cauză, ele pot fi folosite de metodele statice.

6.2.2 Protecţie

În Java există patru grade de protecţie pentru o variabilă aparţinând unei clase:

• privată
• protejată
• publică
• prietenoasă

O variabilă publică este accesibilă oriunde este accesibil numele clasei. Cuvântul rezervat este public.

O variabilă protejată este accesibilă în orice clasă din pachetul căreia îi aparţine clasa în care este declarată. În acelaşi timp, variabila este accesibilă în toate subclasele clasei date, chiar dacă ele aparţin altor pachete. Cuvântul rezervat este protected.

O variabilă privată este accesibilă doar în interiorul clasei în care a fost declarată. Cuvântul rezervat este private.

O variabilă care nu are nici o declaraţie relativă la gradul de protecţie este automat o variabilă prietenoasă. O variabilă prietenoasă este accesibilă în pachetul din care face parte clasa în interiorul căreia a fost declarată, la fel ca şi o variabilă protejată. Dar, spre deosebire de variabilele protejate, o variabilă prietenoasă nu este accesibilă în subclasele clasei date dacă aceste sunt declarate ca aparţinând unui alt pachet. Nu există un cuvânt rezervat pentru specificarea explicită a variabilelor prietenoase.

O variabilă nu poate avea declarate mai multe grade de protecţie în acelaşi timp. O astfel de declaraţie este semnalată ca eroare de compilare.

6.2.3 Accesarea unei variabile

Accesarea unei variabile declarate în interiorul unei clasei se face folosindu-ne de o expresie de forma:

ReferinţăInstanţă.NumeVariabilă

Referinţa către o instanţă trebuie să fie referinţă către clasa care conţine variabila. Referinţa poate fi valoarea unei expresii mai complicate, ca de exemplu un element dintr-un tablou de referinţe.

În cazul în care avem o variabilă statică, aceasta poate fi accesată şi fără să deţinem o referinţă către o instanţă a clasei. Sintaxa este, în acest caz:

NumeClasă.NumeVariabilă

6.2.4 Vizibilitate

O variabilă poate fi ascunsă de declaraţia unei alte variabile cu acelaşi nume. De exemplu, dacă într-o clasă avem declarată o variabilă cu numele unu şi într-o subclasă a acesteia avem declarată o variabilă cu acelaşi nume, atunci variabila din superclasă este ascunsă de cea din clasă. Totuşi, variabila din superclasă există încă şi poate fi accesată în mod explicit. Expresia de referire este, în acest caz:

NumeSuperClasă.NumeVariabilă

sau

super.NumeVariabilă

în cazul în care superclasa este imediată.

La fel, o variabilă a unei clase poate fi ascunsă de o declaraţie de variabilă dintr-un bloc de instrucţiuni. Orice referinţă la ea va trebui făcută în mod explicit. Expresia de referire este, în acest caz:

this.NumeVariabilă

6.2.5 Variabile predefinite: this şi super

În interiorul fiecărei metode non-statice dintr-o clasă există predefinite două variabile cu semnificaţie specială. Cele două variabile sunt de tip referinţă şi au aceeaşi valoare şi anume o referinţă către obiectul curent. Diferenţa dintre ele este tipul.

Prima dintre acestea este variabila this care are tipul referinţă către clasa în interiorul căreia apare metoda. A doua este variabila super al cărei tip este o referinţă către superclasa imediată a clasei în care apare metoda. În interiorul obiectelor din clasa Object nu se poate folosi referinţa super pentru că nu există nici o superclasă a clasei de obiecte Object.

În cazul în care super este folosită la apelul unui constructor sau al unei metode, ea acţionează ca un cast către superclasa imediată.

6.3 Metodele unei clase

Fiecare clasă îşi poate defini propriile sale metode pe lângă metodele pe care le moşteneşte de la superclasa sa. Aceste metode definesc operaţiile care pot fi executate cu obiectul respectiv. În cazul în care una dintre metodele moştenite nu are o implementare corespunzătoare în superclasă, clasa îşi poate redefini metoda după cum doreşte.

În plus, o clasă îşi poate defini metode de construcţie a obiectelor şi metode de eliberare a acestora. Metodele de construcţie sunt apelate ori de câte ori este alocat un nou obiect din clasa respectivă. Putem declara mai multe metode de construcţie, ele diferind prin parametrii din care trebuie construit obiectul.

Metodele de eliberare a obiectului sunt cele care eliberează resursele ocupate de obiect în momentul în care acesta este distrus de către mecanismul automat de colectare de gunoaie. Fiecare clasă are o singură metodă de eliberare, numită şi finalizator. Apelarea acestei metode se face de către sistem şi nu există nici o cale de control al momentului în care se produce acest apel.

6.3.1 Declararea metodelor

Pentru a declara o metodă, este necesar să declarăm numele acesteia, tipul de valoare pe care o întoarce, parametrii metodei precum şi un bloc în care să descriem instrucţiunile care trebuiesc executate atunci când metoda este apelată. În plus, orice metodă are un număr de modificatori care descriu proprietăţile metodei şi modul de lucru al acesteia.

Declararea precum şi implementarea metodelor se face întotdeauna în interiorul declaraţiei de clasă. Nu există nici o cale prin care să putem scrie o parte dintre metodele unei clase într-un fişier separat care să facă referinţă apoi la declaraţia clasei.

În formă generală, declaraţia unei metode arată în felul următor:

[Modificator]* TipRezultat Declaraţie [ClauzeThrows]* CorpulMetodei

Modificatorii precum şi clauzele throws pot să lipsească.

6.3.1.1 Numele şi parametrii metodelor

Recunoaşterea unei anumite metode se face după numele şi tipul parametrilor săi. Pot exista metode cu acelaşi nume dar având parametri diferiţi. Acest fenomen poartă numele de supraîncărcarea numelui unei metode.

Numele metodei este un identificator Java. Avem toată libertatea în a alege numele pe care îl dorim pentru metodele noastre, dar în general este preferabil să alegem nume care sugerează utilizarea metodei.

Numele unei metode începe de obicei cu literă mică. Dacă acesta este format din mai multe cuvinte, litera de început a fiecărui cuvânt va fi majusculă. În acest mod numele unei metode este foarte uşor de citit şi de depistat în sursă.

Parametrii metodei sunt în realitate nişte variabile care sunt iniţializate în momentul apelului cu valori care controlează modul ulterior de execuţie. Aceste variabile există pe toată perioada execuţiei metodei. Se pot scrie metode care să nu aibă nici un parametru.

Fiind o variabilă, fiecare parametru are un tip şi un nume. Numele trebuie să fie un identificator Java. Deşi avem libertatea să alegem orice nume dorim, din nou este preferabil să alegem nume care să sugereze scopul la care va fi utilizat parametrul respectiv.

Tipul unui parametru este oricare dintre tipurile valide în Java. Acestea poate fi fie un tip primitiv, fie un tip referinţă către obiect, interfaţă sau tablou.

În momentul apelului unei metode, compilatorul încearcă să găsească o metodă în interiorul clasei care să aibă acelaşi nume cu cel apelat şi acelaşi număr de parametri ca şi apelul. Mai mult, tipurile parametrilor de apel trebuie să corespundă cu tipurile parametrilor declaraţi ai metodei găsite sau să poată fi convertiţi la aceştia.

Dacă o astfel de metodă este găsită în declaraţia clasei sau în superclasele acesteia, parametrii de apel sunt convertiţi către tipurile declarate şi se generează apelul către metoda respectivă.

Este o eroare de compilare să declarăm două metode cu acelaşi nume, acelaşi număr de parametri şi acelaşi tip pentru parametrii corespunzători. Într-o asemenea situaţie, compilatorul n-ar mai şti care metodă trebuie apelată la un moment dat.

De asemenea, este o eroare de compilare să existe două metode care se potrivesc la acelaşi apel. Acest lucru se întâmplă când nici una dintre metodele existente nu se potriveşte exact şi când există două metode cu acelaşi nume şi acelaşi număr de parametri şi, în plus, parametrii de apel se pot converti către parametrii declaraţi ai ambelor metode.

Rezolvarea unei astfel de probleme se face prin conversia explicită (cast) de către programator a valorilor de apel spre tipurile exacte ale parametrilor metodei pe care dorim să o apelăm în realitate.

În fine, forma generală de declaraţie a numelui şi parametrilor unei metode este:

NumeMetodă( [TipParametru NumeParametru]

[,TipParametru NumeParametru]* )

6.3.1.2 Modificatori de metode

Modificatorii sunt cuvinte cheie ale limbajului Java care specifică proprietăţi suplimentare pentru o metodă. Iată lista completă a acestora în cazul metodelor:

• static - pentru metodele statice
• abstract - pentru metodele abstracte
• final - pentru metodele finale
• native - pentru metodele native
• synchronized - pentru metodele sincronizate

6.3.1.2.1 Metode statice

În mod normal, o metodă a unei clase se poate apela numai printr-o instanţă a clasei respective sau printr-o instanţă a unei subclase. Acest lucru se datorează faptului că metoda face apel la o serie de variabile ale clasei care sunt memorate în interiorul instanţei şi care au valori diferite în instanţe diferite. Astfel de metode se numesc metode ale instanţelor clasei.

După cum ştim deja, există şi un alt tip de variabile, şi anume variabilele de clasă sau variabilele statice care sunt comune tuturor instanţelor clasei respective şi există pe toată perioada de timp în care clasa este încărcată în memorie. Aceste variabile pot fi accesate fără să avem nevoie de o instanţă a clasei respective.

În mod similar există şi metode statice. Aceste metode nu au nevoie de o instanţă a clasei sau a unei subclase pentru a putea fi apelate pentru că ele nu au voie să folosească variabile care sunt memorate în interiorul instanţelor. În schimb, aceste metode pot să folosească variabilele statice declarate în interiorul clasei.

Orice metodă statică este implicit şi finală.

6.3.1.2.2 Metode abstracte

Metodele abstracte sunt metode care nu au corp de implementare. Ele sunt declarate numai pentru a forţa subclasele care vor să aibă instanţe să implementeze metodele respective.

Metodele abstracte trebuie declarate numai în interiorul claselor care au fost declarate abstracte. Altfel compilatorul va semnala o eroare de compilare. Orice subclasă a claselor abstracte care nu este declarată abstractă trebuie să ofere o implementare a acestor metode, altfel va fi generată o eroare de compilare.

Prin acest mecanism ne asigurăm că toate instanţele care pot fi convertite către clasa care conţine definiţia unei metode abstracte au implementată metoda respectivă dar, în acelaşi timp, nu este nevoie să implementăm în nici un fel metoda chiar în clasa care o declară pentru că nu ştim pe moment cum va fi implementată.

O metodă statică nu poate fi declarată şi abstractă pentru că o metodă statică este implicit finală şi nu poate fi rescrisă.

6.3.1.2.3 Metode finale

O metodă finală este o metodă care nu poate fi rescrisă în subclasele clasei în care a fost declarată. O metodă este rescrisă într-o subclasă dacă aceasta implementează o metodă cu acelaşi nume şi acelaşi număr şi tip de parametri ca şi metoda din superclasă.

Declararea metodelor finale este utilă în primul rând compilatorului care poate genera metodele respective direct în codul rezultat fiind sigur că metoda nu va avea nici o altă implementare în subclase.

6.3.1.2.4 Metode native

Metodele native sunt metode care sunt implementate pe o cale specifică unei anumite platforme. De obicei aceste metode sunt implementate în C sau în limbaj de asamblare. Metoda propriu-zisă nu poate avea corp de implementare pentru că implementarea nu este făcută în Java.

În rest, metodele native sunt exact ca orice altă metodă Java. Ele pot fi moştenite, pot fi statice sau nu, pot fi finale sau nu, pot să rescrie o metodă din superclasă şi pot fi la rândul lor rescrise în subclase.

6.3.1.2.5 Metode sincronizate

O metodă sincronizată este o metodă care conţine cod critic pentru un anumit obiect sau clasă şi nu poate fi rulată în paralel cu nici o altă metodă critică sau cu o instrucţiune synchronized referitoare la acelaşi obiect sau clasă.

Înainte de execuţia metodei, obiectul sau clasa respectivă sunt blocate. La terminarea metodei, acestea sunt deblocate.

Dacă metoda este statică atunci este blocată o întreagă clasă, clasa din care face parte metoda. Altfel, este blocată doar instanţa în contextul căreia este apelată metoda.

6.3.1.3 Protejarea metodelor

Accesul la metodele unei clase este protejat în acelaşi fel ca şi accesul la variabilele clasei. În Java există patru grade de protecţie pentru o metodă aparţinând unei clase:

• privată
• protejată
• publică
• prietenoasă

O metodă declarată publică este accesibilă oriunde este accesibil numele clasei. Cuvântul rezervat este public.

O metodă declarată protejată este accesibilă în orice clasă din pachetul căreia îi aparţine clasa în care este declarată. În acelaşi timp, metoda este accesibilă în toate subclasele clasei date, chiar dacă ele aparţin altor pachete. Cuvântul rezervat este protected.

O metodă declarată privată este accesibilă doar în interiorul clasei în care a fost declarată. Cuvântul rezervat este private.

O metodă care nu are nici o declaraţie relativă la gradul de protecţie este automat o metodă prietenoasă. O metodă prietenoasă este accesibilă în pachetul din care face parte clasa în interiorul căreia a fost declarată la fel ca şi o metodă protejată. Dar, spre deosebire de metodele protejate, o metodă prietenoasă nu este accesibilă în subclasele clasei date dacă aceste sunt declarate ca aparţinând unui alt pachet. Nu există un cuvânt rezervat pentru specificarea explicită a metodelor prietenoase.

O metodă nu poate avea declarate mai multe grade de protecţie în acelaşi timp. O astfel de declaraţie este semnalată ca eroare de compilare.

6.3.2 Clauze throws

Dacă o metodă poate arunca o excepţie, adică să apeleze instrucţiunea throw, ea trebuie să declare tipul acestor excepţii într-o clauză throws. Sintaxa acesteia este:

throws NumeTip [, NumeTip]*

Numele de tipuri specificate în clauza throws trebuie să fie accesibile şi să fie asignabile la tipul de clasă Throwable. Dacă o metodă conţine o clauză throws, este o eroare de compilare ca metoda să arunce un obiect care nu este asignabil la compilare la tipurile de clase Error, RunTimeException sau la tipurile de clase specificate în clauza throws.

Dacă o metodă nu are o clauză throws, este o eroare de compilare ca aceasta să poată arunca o excepţie normală din interiorul corpului ei.

6.3.3 Apelul metodelor

Pentru a apela o metodă a unei clase este necesar să dispunem de o cale de acces la metoda respectivă. În plus, trebuie să dispunem de drepturile necesare apelului metodei.

Sintaxa efectivă de acces este următoarea:

CaleDeAcces.Metodă( Parametri )

În cazul în care metoda este statică, pentru a specifica o cale de acces este suficient să furnizăm numele clasei în care a fost declarată metoda. Accesul la numele clasei se poate obţine fie importând clasa sau întreg pachetul din care face parte clasa fie specificând în clar numele clasei şi drumul de acces către aceasta.

De exemplu, pentru a accesa metoda random definită static în clasa Math aparţinând pachetului java.lang putem scrie:

double aleator = Math.random();

sau, alternativ:

double aleator = java.lang.Math.random();

În cazul claselor definite în pachetul java.lang nu este necesar nici un import pentru că acestea sunt implicit importate de către compilator.

Cea de-a doua cale de acces este existenţa unei instanţe a clasei respective. Prin această instanţă putem accesa metodele care nu sunt declarate statice, numite uneori şi metode ale instanţelor clasei. Aceste metode au nevoie de o instanţă a clasei pentru a putea lucra, pentru că folosesc variabile non-statice ale clasei sau apelează alte metode non-statice. Metodele primesc acest obiect ca pe un parametru ascuns.

De exemplu, având o instanţă a clasei Object sau a unei subclase a acesteia, putem obţine o reprezentare sub formă de şir de caractere prin:

Object obiect = new Object();
String sir = obiect.toString();

În cazul în care apelăm o metodă a clasei din care face parte şi metoda apelantă putem să renunţăm la calea de acces în cazul metodelor statice, scriind doar numele metodei şi parametrii. Pentru metodele specifice instanţelor, putem renunţa la calea de acces, dar în acest caz metoda accesează aceeaşi instanţă ca şi metoda apelantă. În cazul în care metoda apelantă este statică, specificarea unei instanţe este obligatorie în cazul metodelor de instanţă.

Parametrii de apel servesc împreună cu numele la identificarea metodei pe care dorim să o apelăm. Înainte de a fi transmişi, aceştia sunt convertiţi către tipurile declarate de parametri ai metodei, după cum este descris mai sus.

Specificarea parametrilor de apel se face separându-i prin virgulă. După ultimul parametru nu se mai pune virgulă. Dacă metoda nu are nici un parametru, parantezele rotunde sunt în continuare necesare. Exemple de apel de metode cu parametri:

String numar = String.valueOf( 12 );
// 12 -> String
double valoare = Math.abs( 12.54 );
// valoare absolută
String prima = numar.substring( 0, 1 );
// prima litera ^

6.3.4 Valoarea de retur a unei metode

O metodă trebuie să-şi declare tipul valorii pe care o întoarce. În cazul în care metoda doreşte să specifice explicit că nu întoarce nici o valoare, ea trebuie să declare ca tip de retur tipul void ca în exemplul:

void a() { … }

În caz general, o metodă întoarce o valoare primitivă sau un tip referinţă. Putem declara acest tip ca în:

Thread cautaFirulCurent() { … }
long abs( int valoare ) { … }

Pentru a returna o valoare ca rezultat al execuţiei unei metode, trebuie să folosim instrucţiunea return, aşa cum s-a arătat în secţiunea dedicată instrucţiunilor. Instrucţiunea return trebuie să conţină o expresie a cărei valoare să poată fi convertită la tipul declarat al valorii de retur a metodei.

De exemplu:

long abs( int valoare ) {
return Math.abs( valoare );
}

Metoda statică abs din clasa Math care primeşte un parametru întreg returnează tot un întreg. În exemplul nostru, instrucţiunea return este corectă pentru că există o cale de conversie de la întreg la întreg lung, conversie care este apelată automat de compilator înainte de ieşirea din metodă.

În schimb, în exemplul următor:

int abs( long valoare ) {
return Math.abs( valoare );
}

compilatorul va genera o eroare de compilare pentru că metoda statică abs din clasa Math care primeşte ca parametru un întreg lung întoarce tot un întreg lung, iar un întreg lung nu poate fi convertit sigur la un întreg normal pentru că există riscul deteriorării valorii, la fel ca la atribuire.

Rezolvarea trebuie să conţină un cast explicit:

int abs( long valoare ) {
return ( int )Math.abs( valoare );
}

În cazul în care o metodă este declarată void, putem să ne întoarcem din ea folosind instrucţiunea return fără nici o expresie. De exemplu:

void metoda() {
…
if( … )
return;
…
}

Specificarea unei expresii în acest caz duce la o eroare de compilare. La fel şi în cazul în care folosim instrucţiunea return fără nici o expresie în interiorul unei metode care nu este declarată void.

6.3.5 Vizibilitate

O metodă este vizibilă dacă este declarată în clasa prin care este apelată sau într-una din superclasele acesteia. De exemplu, dacă avem următoarea declaraţie:

class A {
…
void a() { … }
}
class B extends A {
void b() {
a();
c();
…
}
void c() { .. }
…
}

Apelul metodei a în interiorul metodei b din clasa B este permis pentru că metoda a este declarată în interiorul clasei A care este superclasă pentru clasa B. Apelul metodei c în aceeaşi metodă b este permis pentru că metoda c este declarată în aceeaşi clasă ca şi metoda a.

Uneori, o subclasă rescrie o metodă dintr-o superclasă a sa. În acest caz, apelul metodei respective în interiorul subclasei duce automat la apelul metodei din subclasă. Dacă totuşi dorim să apelăm metoda aşa cum a fost ea definită în superclasă, putem prefixa apelul cu numele superclasei. De exemplu:

class A {
…
void a() { … }
}
class B extends A {
void a() { .. }
void c() {
a();// metoda a din clasa B
A.a();// metoda a din clasa A
…
}
…
}

Desigur, pentru a "vedea" o metodă şi a o putea apela, este nevoie să avem drepturile necesare.

6.4 Iniţializatori statici

La încărcarea unei clase sunt automat iniţializate toate variabilele statice declarate în interiorul clasei. În plus, sunt apelaţi toţi iniţializatorii statici ai clasei.

Un iniţializator static are următoarea sintaxă:

static BlocDeInstrucţiuni

Blocul de instrucţiuni este executat automat la încărcarea clasei. De exemplu, putem defini un iniţializator static în felul următor:

class A {
static double a;
static int b;
static {
a = Math.random();
// număr dublu între 0.0 şi 1.0
b = ( int )( a * 500 );
// număr întreg între 0 şi 500
}
…
}

Declaraţiile de variabile statice şi iniţializatorii statici sunt executate în ordinea în care apar în clasă. De exemplu, dacă avem următoarea declaraţie de clasă:

class A {
static int i = 11;
static {
i += 100;
i %= 55;
}
static int j = i + 1;
}

valoarea finală a lui i va fi 1 ( ( 11 + 100 ) % 55 ) iar valoarea lui j va fi 2.

6.5 Constructori şi finalizatori

6.5.1 constructori

La crearea unei noi instanţe a unei clase sistemul alocă automat memoria necesară instanţei şi o iniţializează cu valorile iniţiale specificate sau implicite. Dacă dorim să facem iniţializări suplimentare în interiorul acestei memorii sau în altă parte putem descrie metode speciale numite constructori ai clasei.

Putem avea mai mulţi constructori pentru aceeaşi clasă, aceştia diferind doar prin parametrii pe care îi primesc. Numele tuturor constructorilor este acelaşi şi este identic cu numele clasei.

Declaraţia unui constructor este asemănătoare cu declaraţia unei metode oarecare, cu diferenţa că nu putem specifica o valoare de retur şi nu putem specifica nici un fel de modificatori. Dacă dorim să returnăm dintr-un constructor, trebuie să folosim instrucţiunea return fără nici o expresie. Putem însă să specificăm gradul de protecţie al unui constructor ca fiind public, privat, protejat sau prietenos.

Constructorii pot avea clauze throws.

Dacă o clasă nu are constructori, compilatorul va crea automat un constructor implicit care nu ia nici un parametru şi care iniţializează toate variabilele clasei şi apelează constructorul superclasei fără argumente prin super(). Dacă superclasa nu are un constructor care ia zero argumente, se va genera o eroare de compilare.

Dacă o clasă are cel puţin un constructor, constructorul implicit nu mai este creat de către compilator.

Când construim corpul unui constructor avem posibilitatea de a apela, pe prima linie a blocului de instrucţiuni care reprezintă corpul constructorului, un constructor explicit. Constructorul explicit poate avea două forme:

this( [Parametri] );

super( [Parametri] );

Cu această sintaxă apelăm unul dintre constructorii superclasei sau unul dintre ceilalţi constructori din aceeaşi clasă. Aceste linii nu pot apărea decât pe prima poziţie în corpul constructorului. Dacă nu apar acolo, compilatorul consideră implicit că prima instrucţiune din corpul constructorului este:

super();

Şi în acest caz se va genera o eroare de compilare dacă nu există un constructor în superclasă care să lucreze fără nici un parametru.

După apelul explicit al unui constructor din superclasă cu sintaxa super( … ) este executată în mod implicit iniţializarea tuturor variabilelor de instanţă (non-statice) care au iniţializatori expliciţi. După apelul unui constructor din aceeaşi clasă cu sintaxa this( … ) nu există nici o altă acţiune implicită, deci nu vor fi iniţializate nici un fel de variabile. Aceasta datorită faptului că iniţializarea s-a produs deja în constructorul apelat.

Iată şi un exemplu:

class A extends B {
String valoare;
A( String val ) {
// aici există apel implicit
// al lui super(), adică B()
valoare = val;
}
A( int val ) {
this( String.valueOf( val ) );// alt constructor
}
} ^

6.5.2 Finalizatori

În Java nu este nevoie să apelăm în mod explicit distrugerea unei instanţe atunci când nu mai este nevoie de ea. Sistemul oferă un mecanism de colectare a gunoaielor care recunoaşte situaţia în care o instanţă de obiect sau un tablou nu mai sunt referite de nimeni şi le distruge în mod automat.

Acest mecanism de colectare a gunoaielor rulează pe un fir de execuţie separat, de prioritate mică. Nu avem nici o posibilitate să aflăm exact care este momentul în care va fi distrusă o instanţă. Totuşi, putem specifica o funcţie care să fie apelată automat în momentul în care colectorul de gunoaie încearcă să distrugă obiectul.

Această funcţie are nume, număr de parametri şi tip de valoare de retur fixe:

void  finalize()

După apelul metodei de finalizare (numită şi finalizator), instanţa nu este încă distrusă până la o nouă verificare din partea colectorului de gunoaie. Această comportare este necesară pentru că instanţa poate fi revitalizată prin crearea unei referinţe către ea în interiorul finalizatorului.

Totuşi, finalizatorul nu este apelat decât o singură dată. Dacă obiectul revitalizat redevine candidat la colectorul de gunoaie, acesta este distrus fără a i se mai apela finalizatorul. Cu alte cuvinte, un obiect nu poate fi revitalizat decât o singură dată.

Dacă în timpul finalizării apare o excepţie, ea este ignorată şi finalizatorul nu va mai fi apelat din nou.

6.5.3 Crearea instanţelor

O instanţă este creată folosind o expresie de alocare care foloseşte cuvântul rezervat new. Iată care sunt paşii care sunt executaţi la apelul acestei expresii:

• Se creează o nouă instanţă de tipul specificat. Toate variabilele instanţei sunt iniţializate pe valorile lor implicite.
• Se apelează constructorul corespunzător în funcţie de parametrii care sunt transmişi în expresia de alocare. Dacă instanţa este creată prin apelul metodei newInstance, se apelează constructorul care nu ia nici un argument.
• După creare, expresia de alocare returnează o referinţă către instanţa nou creată.

Exemple de creare:

A o1 = new A();
B o2 = new B();
class C extends B {
String valoare;
C( String val ) {
// aici există apel implicit
// al lui super(), adică B()
valoare = val;
}
C( int val ) {
this( String.valueOf( val ) );
}
}
C o3 = new C( "Vasile" );
C o4 = new C( 13 );

O altă cale de creare a unui obiect este apelul metodei newInstance declarate în clasa Class. Iată paşii de creare în acest caz:

• Se creează o nouă instanţă de acelaşi tip cu tipul clasei pentru care a fost apelată metoda newInstance. Toate variabilele instanţei sunt iniţializate pe valorile lor implicite.
• Este apelat constructorul obiectului care nu ia nici un argument.
• După creare referinţa către obiectul nou creat este returnată ca

valoare a metodei newInstance. Tipul acestei referinţe va fi Object în timpul compilării şi tipul clasei reale în timpul execuţiei.

6.6 Derivarea claselor

O clasă poate fi derivată dintr-alta prin folosirea în declaraţia clasei derivate a clauzei extends. Clasa din care se derivă noua clasă se numeşte superclasă imediată a clasei derivate. Toate clasele care sunt superclase ale superclasei imediate ale unei clase sunt superclase şi pentru clasa dată. Clasa nou derivată se numeşte subclasă a clasei din care este derivată.

Sintaxa generală este:

class SubClasă extends SuperClasă …

O clasă poate fi derivată dintr-o singură altă clasă, cu alte cuvinte o clasă poate avea o singură superclasă imediată.

Clasa derivată moşteneşte toate variabilele şi metodele superclasei sale. Totuşi, ea nu poate accesa decât acele variabile şi metode care nu sunt declarate private.

Putem rescrie o metodă a superclasei declarând o metodă în noua clasă având acelaşi nume şi aceiaşi parametri. La fel, putem declara o variabilă care are acelaşi nume cu o variabilă din superclasă. În acest caz, noul nume ascunde vechea variabilă, substituindu-i-se. Putem în continuare să ne referim la variabila ascunsă din superclasă specificând numele superclasei sau folosindu-ne de variabila super.

Exemplu:

class A {
int a = 1;
void unu() {
System.out.println( a );
}
}
class B extends A {
double a = Math.PI;
void unu() {
System.out.println( a );
}
void doi() {
System.out.println( A.a );
}
void trei() {
unu();
super.unu();
}
}

Dacă apelăm metoda unu din clasa A, aceasta va afişa la consolă numărul 1. Acest apel se va face cu instrucţiunea:

( new A() ).unu();

Dacă apelăm metoda unu din clasa B, aceasta va afişa la consolă numărul PI. Apelul îl putem face de exemplu cu instrucţiunea:

B obiect = new B();
obiect.unu();

Observaţi că în metoda unu din clasa B, variabila referită este variabila a din clasa B. Variabila a din clasa A este ascunsă. Putem însă să o referim prin sintaxa A.a ca în metoda doi din clasa B.

În interiorul clasei B, apelul metodei unu fără nici o altă specificaţie duce automat la apelul metodei unu definite în interiorul clasei B. Metoda unu din clasa B rescrie metoda unu din clasa A. Vechea metodă este accesibilă pentru a o referi în mod explicit ca în metoda trei din clasa B. Apelul acestei metode va afişa mai întâi numărul PI şi apoi numărul 1.

Dacă avem declarată o variabilă de tip referinţă către o instanţă a clasei A, această variabilă poate să conţină în timpul execuţiei şi o referinţă către o instanţă a clasei B. Invers, afirmaţia nu este valabilă.

În clipa în care apelăm metoda unu pentru o variabilă referinţă către clasa A, sistemul va apela metoda unu a clasei A sau B în funcţie de adevăratul tip al referinţei din timpul execuţiei. Cu alte cuvinte, următoarea secvenţă de instrucţiuni:

A tablou[] = new A[2];
tablou[0] = new A();
tablou[1] = new B();
for( int i = 0; i < 2; i++ ) {
tablou[i].unu();
}

va afişa două numere diferite, mai întâi 1 şi apoi PI. Aceasta din cauză că cel de-al doilea element din tablou este, în timpul execuţiei, de tip referinţă la o instanţă a clasei B chiar dacă la compilare este de tipul referinţă la o instanţă a clasei A.

Acest mecanism se numeşte legare târzie, şi înseamnă că metoda care va fi efectiv apelată este stabilită doar în timpul execuţiei şi nu la compilare.

Dacă nu declarăm nici o superclasă în definiţia unei clase, atunci se consideră automat că noua clasă derivă direct din clasa Object, moştenind toate metodele şi variabilele acesteia.

6.7 Interfeţe

O interfaţă este în esenţă o declaraţie de tip ce constă dintr-un set de metode şi constante pentru care nu s-a specificat nici o implementare. Programele Java folosesc interfeţele pentru a suplini lipsa moştenirii multiple, adică a claselor de obiecte care derivă din două sau mai multe alte clase.

Sintaxa de declaraţie a unei interfeţe este următoarea:

Modificatori interface NumeInterf [ extends [Interfaţă][, Interfaţă]*]

Corp

Modificatorii unei interfeţe pot fi doar cuvintele rezervate public şi abstract. O interfaţă care este publică poate fi accesată şi de către alte pachete decât cel care o defineşte. În plus, fiecare interfaţă este în mod implicit abstractă. Modificatorul abstract este permis dar nu obligatoriu.

Numele interfeţelor trebuie să fie identificatori Java. Convenţiile de numire a interfeţelor le urmează în general pe cele de numire a claselor de obiecte.

Interfeţele, la fel ca şi clasele de obiecte, pot avea subinterfeţe. Subinterfeţele moştenesc toate constantele şi declaraţiile de metode ale interfeţei din care derivă şi pot defini în plus noi elemente. Pentru a defini o subinterfaţă, folosim o clauză extends. Aceste clauze specifică superinterfaţa unei interfeţe. O interfaţă poate avea mai multe superinterfeţe care se declară separate prin virgulă după cuvântul rezervat extends. Circularitatea definiţiei subinterfeţelor nu este permisă.

În cazul interfeţelor nu există o rădăcină comună a arborelui de derivare aşa cum există pentru arborele de clase, clasa Object.

În corpul unei declaraţii de interfaţă pot să apară declaraţii de variabile şi declaraţii de metode. Variabilele sunt implicit statice şi finale. Din cauza faptului că variabilele sunt finale, este obligatoriu să fie specificată o valoare iniţială pentru aceste variabile. În plus, această valoare iniţială trebuie să fie constantă (să nu depindă de alte variabile).

Dacă interfaţa este declarată publică, toate variabilele din corpul său sunt implicit declarate publice.

În ceea ce priveşte metodele declarate în interiorul corpului unei interfeţe, acestea sunt implicit declarate abstracte. În plus, dacă interfaţa este declarată publică, metodele din interior sunt implicit declarate publice.

Iată un exemplu de declaraţii de interfeţe:

public interface ObiectSpatial {
final int CUB = 0;
final int SFERA = 1;
double greutate();
double volum();
double raza();
int tip();
}
public interface ObiectSpatioTemporal extends ObiectSpatial {
void centrulDeGreutate( long moment,
double coordonate[] );
long momentInitial();
long momentFinal();
}

Cele două interfeţe definesc comportamentul unui obiect spaţial respectiv al unui obiect spaţio-temporal. Un obiect spaţial are o greutate, un volum şi o rază a sferei minime în care se poate înscrie. În plus, putem defini tipul unui obiect folosindu-ne de o serie de valori constante predefinite precum ar fi SFERA sau CUB.

Un obiect spaţio-temporal este un obiect spaţial care are în plus o poziţie pe axa timpului. Pentru un astfel de obiect, în afară de proprietăţile deja descrise pentru obiectele spaţiale, trebuie să avem în plus un moment iniţial, de apariţie, pe axa timpului şi un moment final. Obiectul nostru nu există în afara acestui interval de timp. În plus, pentru un astfel de obiect putem afla poziţia centrului său de greutate în fiecare moment aflat în intervalul de existenţă.

Pentru a putea lucra cu obiecte spaţiale şi spaţio-temporale este nevoie să definim diverse clase care să implementeze aceste interfeţe. Acest lucru se face specificând clauza implements în declaraţia de clasă. O clasă poate implementa mai multe interfeţe. Dacă o clasă declară că implementează o anumită interfaţă, ea este obligatoriu să implementeze toate metodele declarate în interfaţa respectivă.

De exemplu, putem spune că o minge este un obiect spaţial de tip sferă. În plus, mingea are o poziţie în funcţie de timp şi un interval de existenţă. Cu alte cuvinte, mingea este chiar un obiect spaţio-temporal. Desigur, în afară de proprietăţile spaţio-temporale mingea mai are şi alte proprietăţi precum culoarea, proprietarul sau preţul de cumpărare.

Iată cum ar putea arăta definiţia clasei de obiecte de tip minge:

import java.awt.Color;
class Minge extends Jucarie implements ObiectSpatioTemporal   {
int culoare = Color.red;
double pret = 10000.0;
double raza = 0.25;
long nastere;
long moarte;
// metodele din ObiectSpatial
double greutate() {
return raza * 0.5;
}
double raza() {
return raza;
}
double volum() {
return ( 4.0 / 3.0 ) * Math.PI * raza * raza * raza;
}
int tip() {
return SFERA;
}

// metodele din interfaţa ObiectSpatioTemporal
boolean centrulDeGreutate( long moment,
 double coordonate[] ) {
if( moment < nastere || moment > moarte ) {
return false;
}
…
coordonate[0] = x;
coordonate[1] = y;
coordonate[2] = z;
return true;
}
long momentInitial() {
return nastere;
}
long momentFinal() {
return moarte;
}
int ceCuloare() {
return culoare;
}
double cePret() {
return pret;
}
}

Observaţi că noua clasă Minge implementează toate metodele definite în interfaţa ObiectSpatioTemporal şi, pentru că aceasta extinde interfaţa ObiectSpatial, şi metodele definite în cea din urmă. În plus, clasa îşi defineşte propriile metode şi variabile.

Să presupunem în continuare că avem şi o altă clasă, Rezervor, care este tot un obiect spaţio-temporal, dar de formă cubică. Declaraţia acestei clase ar arăta ca:

class Rezervor extends Constructii implements ObiectSpatioTemporal {

…
}

Desigur, toate metodele din interfeţele de mai sus trebuiesc implementate, plus alte metode specifice.

Să mai observăm că cele două obiecte derivă din clase diferite: Mingea din Jucării iar Rezervorul din Construcţii. Dacă am putea deriva o clasă din două alte clase, am putea deriva Minge din Jucarie şi ObiectSpatioTemporal iar Rezervor din Constructie şi ObiectSpaţioTemporal. Într-o astfel de situaţie, nu ar mai fi necesar ca ObiectSpaţioTemporal să fie o interfaţă, ci ar fi suficient ca acesta să fie o altă clasă.

Din păcate, în Java, o clasă nu poate deriva decât dintr-o singură altă clasă, aşa că este obligatoriu în astfel de situaţii să folosim interfeţele. Dacă ObiectSpaţioTemporal ar fi putut fi o clasă, am fi avut avantajul că puteam implementa acolo metodele cu funcţionare identică din cele două clase discutate, acestea fiind automat moştenite fără a mai fi nevoie de definirea lor de două ori în fiecare clasă în parte.

Putem crea în continuare metode care să lucreze cu obiecte spaţio-temporale, de exemplu o metodă care să afle distanţa unui corp spaţio-temporal faţă de un punct dat la momentul său iniţial. O astfel de metodă se poate scrie o singură dată, şi poate lucra cu toate clasele care implementează interfaţa noastră. De exemplu:

…
double distanta( double punct[], ObiectSpatioTemporal obiect ) {
double coordonate[] = new double[3];
obiect.centrulDeGreutate( obiect.momentInitial(),
coordonate );
double x = coordonate[0] - punct[0];
double y = coordonate[1] - punct[1];
double z = coordonate[2] - punct[2];
return Math.sqrt( x * x + y * y + z * z );
}

Putem apela metoda atât cu un obiect din clasa Minge cât şi cu un obiect din clasa Rezervor. Compilatorul nu se va plânge pentru că el ştie că ambele clase implementează interfaţa ObiectSpaţioTemporal, aşa că metodele apelate în interiorul calculului distanţei (momentInitial şi centruDeGreutate) sunt cu siguranţă implementate în ambele clase. Deci, putem scrie:

Minge minge;
Rezervor rezervor;
double punct[] = { 10.0, 45.0, 23.0 };
distanţa( punct, minge );
distanţa( punct, rezervor );

Desigur, în mod normal ar fi trebuit să proiectăm şi un constructor sau mai mulţi care să iniţializeze obiectele noastre cu valori rezonabile. Aceşti constructori ar fi stat cu siguranţă în definiţia claselor şi nu în definiţia interfeţelor. Nu avem aici nici o cale de a forţa definirea unui anumit constructor cu ajutorul interfeţei.