Am văzut în episodul XVII cum putem grupa diferite informații în obiecte, dar modul în care erau create obiectele respective era puțin greoi. Am lucrat cu obiecte simple, dar este ușor să ne imaginăm că, pe măsură ce obiectele devin mai complexe, e destul de complicat să stabilim valori pentru fiecare proprietate în parte.
Constructori
Avem la dispoziție posibilitatea de a scrie funcții care creează obiectele noastre. De exemplu, pentru o persoană ale cărei proprietăți sunt numele și vârsta, am putea avea o funcție cu doi parametri (un string și un număr întreg) care să creeze obiectul respectiv.
Putem scrie o funcție simplă care să returneze un obiect:
|
1 2 3 4 5 6 |
def creeazaPersoana(nume: String, oVarsta: Int): Persoana = { val p = new Persoana() p.nume = nume p.varsta = oVarsta return p } |
Este o variantă bună, chiar foarte utilă în unele situații. Funcția ar putea fi folosită astfel:
|
1 |
val elev = creeazaPersoana("Dragoș", 17) |
Există și o alternativă: un constructor. Constructorii sunt funcții speciale care creează obiecte. Ele sunt definite în interiorul clasei. Spre deosebire de funcțiile obișnuite, constructorii nu au tip; va fi returnat obiectul creat, tipul fiind dat de clasa din care face parte constructorul.
De asemenea, numele constructorului este: this. O clasă poate avea mai mulți constructori, cu parametri diferiți, atâta timp cât nu există pericolul să apară confuzii (vom vedea puțin mai încolo).
Să transformăm funcția noastră într-un constructor:
|
1 2 3 4 5 |
def this(unNume: String, oVarsta: Int) = { this() nume = unNume varsta = oVarsta } |
Observăm că nu apare o instrucțiune return; se va returna automat, la sfârșit, obiectul creat.
Mai observăm că pentru proprietăți nu mai specificăm obiectul; nu mai este nevoie fiindcă se operează asupra obiectului care este creat.
De asemenea, se poate observa că pe prima linie a constructorului apare apelul this(). Funcția this() , este în cazul nostru un constructor de bază. În Scala este necesar ca pe prima linie a unui constructor să fie apelat un alt constructor sau constructorul de bază.
Am spus că un constructor apare în interiorul clasei; întreaga noastră clasă ar arăta acum așa:
|
1 2 3 4 5 6 7 8 9 10 |
class Persoana { var nume: String var varsta: Int def this(unNume: String, oVarsta: Int) { this() nume = unNume varsta = oVarsta } } |
Pentru a utiliza constructorul, va trebui să îl apelăm în momentul creării obiectului. Crearea se va realiza acum folosind cuvântul new, urmat de apelul constructorului. Un exemplu ar putea fi:
|
1 |
val p = new Persoana("Dragoș", 17) |
Poate v-ați dat seama că și în episodul anterior am apelat, de fapt, un constructor: unul fără parametri. Acesta există întotdeauna și nu face nimic special în afară de crearea obiectului; poartă denumirea de constructor de bază. Dacă dorim, putem să îl redefinim, și clasa noastră ar putea arată asa:
|
1 2 3 4 |
class Persoana(unNume: String, oVarsta: Int) { var nume: String = unNume var varsta: Int = oVarsta } |
Se poate observa modul în care se declara constructorul de bază. După numele clasei apar parametrii constructorului de bază și tipurile lor. Valorile parametrilor pot fi utilizate la inițializarea valorilor proprietăților clasei.
Până acum, clasa Persoana a avut 2 constructori: un constructor de bază fără parametri și unul cu parametri. În urma ultimei modificări, clasa noastră are un singur constructor cu parametri.
Dacă dorim, putem să mai adăugăm unul. De exemplu, poate dorim să creăm multe persoane care au 18 ani și am vrea să specificăm doar numele. Am putea avea constructorul:
|
1 2 3 |
def this(unNume: String) { this(unNume, 18) } |
După cum am văzut anterior, acest al doilea constructor trebuie pe prima linie să apeleze constructorul de bază cu 2 parametri. Unul dintre aceștia va fi numele, iar a doilea va fi valoarea constantă 18.
Acesta ar putea fi folosit astfel:
|
1 |
val p = new Persoana("Antoniu") |
Dar, să presupunem că dorim să creăm acum multe persoane care au 16 ani. Am putea crede că putem crea un nou constructor:
|
1 2 3 |
def this(unNume: String) { this(unNume, 16) } |
De fapt, nu se poate fiindcă acești ultimi doi constructori nu pot fi diferențiați în momentul apelului. Dacă ar exista amândoi, atunci un apel ca cel de mai sus (care creează o persoană cu numele Antoniu) nu ar ști exact pe care dintre ei să îl apeleze. Nu ajută cu nimic dacă schimbăm numele parametrului; tot nu există posibilitatea de a diferenția constructorii.
În schimb, putem crea un constructor care să specifice doar vârsta:
|
1 2 3 |
def this(oVarsta: Int) { this("Dana", oVarsta) } |
Putem crea acum multe persoane cu numele Dana, specificând pentru fiecare doar vârsta; de exemplu:
|
1 |
val p = new Persoana(14) |
Avem deja trei constructori și îi putem folosi pe toți:
|
1 2 3 |
val p1 = new Persoana("Antoniu") val p2 = new Persoana(14) val p3 = new Persoana("Sofia", 15) |
Am creat o persoană cu numele Antoniu și vârsta de 16 ani, una cu numele Dana și vârsta de 14 ani și una cu numele Sofia și vârsta de 15 ani.
Nu trebuie neapărat să ne oprim aici; am mai putea avea un constructor în care să apară prima dată vârsta și apoi numele; nu are prea mult sens, dar e posibil. Nu va fi confundat cu cel în care precizăm numele și apoi vârsta fiindcă ordinea este diferită.
Obiecte în obiecte
Proprietățile obiectelor au tipuri. Ce fel de tipuri? În principiu, de orice fel, inclusiv diferite clase. Așadar, o proprietate a unui obiect poate fi, la rândul său, un obiect.
Să ne imaginăm că persoanele noastre au și o adresă. O adresă ar fi un obiect care să conțină informații cum ar fi strada, numărul, orașul etc. Pentru simplitate, ne vom limita la stradă și număr. Clasa noastră ar putea arăta astfel:
|
1 2 3 4 |
class Adresa(oStrada: String, unNumar: String) { var strada = oStrada var numar = unNumar } |
La prima vedere ar putea părea ciudat că numărul este un string; dar, adresele pot avea numere ciudate cum ar fi 46B. Este important să ne gândim ce tip se potrivește cu informația pe care dorim să o păstrăm.
Acum, putem modifica clasa Persoana pentru ca ea să conțină și o adresă; vom avea doar un constructor care să ne permită să precizăm numele, vârsta și adresa.
|
1 2 3 4 5 |
class Persoana(unNume: String, oVarsta: Int, oAdresa: Adresa) { var nume: String = unNume var varsta: Int = oVarsta var adresa: Adresa = oAdresa } |
Să vedem cum accesăm obiectele din obiecte. Nu e foarte complicat; trebuie doar să adaugăm puncte...
Mai exact, dacă elev este obiectul, atunci elev.adresa este obiectul din interior (o proprietate o primului obiect) și elev.adresa.strada, respectiv elev.adresa.numar, sunt proprietățile acestui obiect din interior.
Nu este nepărat nevoie să ne oprim aici. Putem avea obiecte în obiecte în obiecte în obiecte etc.
Să vedem acum un program complet:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
class Adresa(oStrada: String, unNumar: String) { var strada = oStrada var numar = unNumar } class Persoana(unNume: String, oVarsta: Int, oAdresa: Adresa) { var nume: String = unNume var varsta: Int = oVarsta var adresa: Adresa = oAdresa } object Obiecte extends App { val adresa = new Adresa("Ferdinand I", "47") val elev = new Persoana("Dragoș", 17, adresa) print(elev.nume) print(": ") print(elev.varsta) print(" - "); print(elev.adresa.strada); print(" "); print(elev.adresa.numar); } |
Observăm că am ales să nu punem clasa Adresa în interiorul clasei Persoana deși am fi putut. Așa, o putem utiliza independent în alte scopuri. Alternativa ar fi fost:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
class Persoana(unNume: String, oVarsta: Int, oAdresa: Persoana.Adresa) { var nume: String = unNume var varsta: Int = oVarsta var adresa: Persoana.Adresa = oAdresa } object Persoana { class Adresa(oStrada: String, unNumar: String) { var strada = oStrada var numar = unNumar } } object Obiecte extends App { val adresa = new Persoana.Adresa("Ferdinand I", "47") val elev = new Persoana("Dragoș", 17, adresa) print(elev.nume) print(": ") print(elev.varsta) print(" - "); print(elev.adresa.strada); print(" "); print(elev.adresa.numar); } |
Observați modificarea esențială din linia 5. Clasa Adresa nu mai există decât în interiorul obiectului Persoana și nu mai poate fi utilizată independent.
Tot în linia 15 observăm că avem o variabilă pe care nu o folosim decât în linia 16; nu avem nevoie de ea. Putem scăpa de ea dacă ne gândim că un constructor returnează un obiect și în linia 16 avem nevoie de doar un astfel de obiect. Am putea rescrie liniile 15 și 16 astfel:
|
1 |
val elev = new Persoana("Dragoș", 17, new Adresa("Ferdinand I", "47")) |
sau (dacă am ales varianta în care clasa Adresa este în interiorul obiectului Persoana):
|
1 |
val elev = new Persoana("Dragoș", 17, new Persoana.Adresa("Ferdinand I", "47")) |
E mai bine să definim clasele în interiorul altor clase sau nu? Depinde, dacă au sens să existe separat! În cazul nostru, probabil că e bine ca adresele să existe separat de persoane fiindcă s-ar putea să lucrăm și cu instituții, care au la rândul lor adrese și ar fi de dorit să nu trebuiască să avem o nouă clasă Adresa în interiorul clasei Institutie, care să fie la fel ca cea din interiorul clasei Persoana.
Obiecte de companie
În secțiunea anterioră dar și în episoadele anterioare am folosit, în cadrul codului scris în Scala, cuvântul object. În Scala, există clase pentru care avem o singură instanță. Această instanță poartă numele de obiect unic (englezescul singleton).
Ca și precizare, în Scala, putem defini fie clase care pot fi folosite pentru a crea obiecte, fie obiecte unice. Aceste obiecte unice se definesc folosing cuvântul object, iar acestea pot fi accesate prin numele obiectului în locul numelui. De exemplu, am avut anterior construcția:
|
1 |
new Persoana.Adresa("Ferdinand I", "47") |
Clasa Adresa este definită în cadrul obiectului Persoana .
Dacă un obiect unic definit de noi are acelasi nume cu o clasă, atunci acesta poartă numele de companion object (obiect de companie sau obiect însoțitor).
Un alt exemplu este chiar programul nostru: obiectul Obiecte.
