În programarea orientată pe obiecte, atunci când creați obiecte din anumite clase, este uneori necesar să apelați câteva metode speciale ale acelor clase, cunoscute sub numele de constructori.
Constructorul unei clase este o pseudo-metodă care nu returnează un tip, are același nume cu cel al clasei și se apelează utilizând cuvântul cheie new. Sarcina constructorului este aceea de a inițializa memoria alocată pentru obiect, unde vor fi stocate câmpurile sale (cele care nu sunt statice – vom afla despre ceea ce înseamnă static în viitor).
Să luăm din nou clasa Cuptor, de acum două lecții:
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
class Cuptor { private string model; // Campul "model" private string culoare; private int greutate; private int inaltime; private int latime; private int lungime; public string Model // Proprietatea "Model" { get // Getter-ul proprietatii "Model" { return this.model; } set // Setter-ul proprietatii "Model" { this.model = value; } } public string Culoare { get { return this.culoare; } set { this.culoare = value; } } public int Greutate { get { return this.greutate; } set { this.greutate = value; } } public int Inaltime { get { return this.inaltime; } set { this.inaltime = value; } } public int Latime { get { return this.latime; } set { this.latime = value; } } public int Lungime { get { return this.lungime; } set { this.lungime = value; } } public Cuptor() // Constructor prestabilit { this.model = "EKK6450AOX"; this.culoare = "Gri"; this.greutate = 40; this.inaltime = 85; this.latime = 60; this.lungime = 60; } public void Porneste() // Metoda Porneste { Console.WriteLine("Cuptor pornit!"); } public void Opreste() { Console.WriteLine("Cuptor oprit!"); } } |
În lecția anterioară am aflat ce sunt câmpurile și proprietățile, și deja cunoaștem conceptul de metode. Deci, în codul de mai sus, există o singură bucată rămasă neanalizată încă. Anume, aceasta:
|
1 2 3 4 5 6 7 8 9 |
public Cuptor() // constructor prestabilit { this.model = "EKK6450AOX"; this.culoare = "Gri"; this.greutate = 40; this.inaltime = 85; this.latime = 60; this.lungime = 60; } |
Semi-metoda de mai sus se numește constructorul clasei noastre. De ce o numesc semi-metodă? Ei bine, puteți vedea în mod clar că nu returnează un tip, ceea ce o exclude din categoria funcții, dar de asemenea nu folosește cuvântul cheie void, așa cum orice metodă ar trebui.
Un alt lucru pe care l-ați observat este că identificatorul (numele) constructorului este identic cu identificatorul clasei. Să vedem ce s-ar fi întâmplat dacă am fi numit constructorul în mod diferit:
|
1 2 3 4 5 6 7 |
class Cuptor { public UnNumeDeConstructor() { } } |
Codul de mai sus ne va da o eroare: Metoda trebuie să returneze un tip (Method must have a return type). Deci, compilatorul nu o mai recunoaște ca fiind un constructor, ci mai degrabă încearcă să o trateze ca o funcție obișnuită. Din acest lucru, rezultă următoarea concluzie: în C# este obligatoriu ca numele fiecărui constructor să fie identic cu numele clasei în care este declarat. De asemenea, nu este permisă declararea unei metode al cărei nume este identic cu numele clasei (și implicit, numele constructorilor). Dacă totuși, o metodă este declarată cu același nume cu al clasei, aceasta va cauza o eroare de compilare ‘Cuptor’: numele de membri nu pot fi identice cu tipul ce le înglobează (‘Cuptor’: member names cannot be the same as their enclosing type).
Modul în care declarăm un constructor este oarecum similar cu modul în care declarăm metodele:
|
1 |
<modificatori> <nume_clasa>(<lista_parameti>) |
Despre modificatori vom învăța în viitor, deși am întâlnit deja câțiva dintre ei (private, public, static). În afară de aceasta, lista de parametri este similară cu modul în care declarăm metodele cu parametri. În următoarea lecție, vom învăța cum să creăm copii ale schiței obiectelor noastre. Dar, așa cum am învățat în lecția Proprietăți, copiile noastre nu ne-ar fi de mare folos dacă nu le-am putea individualiza:
|
1 2 3 |
Cuptor copieCuptor = new Cuptor(); copieCuptor.Model = "EKK6450AOX"; copieCuptor.Culoare = "alb"; |
Exemplul de mai sus funcționează perfect, dar are multe linii, mai ales dacă trebuie să specificăm o mulțime de proprietăți. În schimb, am putea să facem acest lucru direct atunci când creăm copia obiectului, utilizând un constructor cu parametri. Să spunem că avem acest cod:
|
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
class Cuptor { private string model; // Campul "model" private string culoare; private int greutate; private int inaltime; private int latime; private int lungime; public string Model { get { return this.model; } set { this.model = value; } } public string Culoare { get { return this.culoare; } set { this.culoare = value; } } public int Greutate { get { return this.greutate; } set { this.greutate = value; } } public int Inaltime { get { return this.inaltime; } set { this.inaltime = value; } } public int Latime { get { return this.latime; } set { this.latime = value; } } public int Lungime { get { return this.lungime; } set { this.lungime = value; } } public Cuptor() { this.model = "EKK6450AOX"; this.culoare = "Gri"; this.greutate = 40; this.inaltime = 85; this.latime = 60; this.lungime = 60; } } |
După aceea, putem crea o copie a obiectului după cum urmează:
|
1 |
Cuptor copieCuptor = new Cuptor("EKK6450AOX", "alb", 40, 85, 60, 60); |
Un mod mult mai scurt și mai elegant de a defini o copie nouă! Un lucru de observat aici – am definit variabilele parametrilor cu același nume cu al câmpurile noastre. Asta lucru este total acceptabil. De asemenea, observați că domeniul de definiție al parametrilor constructorilor este identic cu domeniul parametrilor metodelor obișnuite: este disponibil numai pentru corpul constructorului. Deși există o capcană în privința acestui fapt. Am explicat anterior că folosirea cuvântului cheie this este opțională, și indică faptul că ne referim la chestiuni legate de copia curentă a obiectului pe care îl manipulăm la momentul respectiv. Deci, am fi putut scrie acest lucru:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Cuptor { //campuri aici public Cuptor(string model, string culoare, int greutate, int inaltime, int latime, int lungime) { model = model; culoare = culoare; greutate = greutate; inaltime = inaltime; latime = latime; lungime = lungime; } } |
Dar în acest caz, am face o greșeală fatală, pentru că fără cuvântul cheie this, nu facem referire de fapt la câmpurile noastre, ci la variabilele parametru ale constructorului nostru. Deci, în loc să atribuim valoarea parametrilor câmpurilor noastre, de fapt atribuim variabilelor parametrilor propriile lor valori. Acesta este unul dintre motivele pentru care am spus că deși opțional, este indicat să folosim întotdeauna this atunci când ne referim la o instanță.
Alte asemănări cu metodele: constructorii noștri pot avea parametri opționali și, de asemenea, putem avea constructori supraîncărcați:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
class Cuptor { public Cuptor() //fara parametri { } public Cuptor(string model) //un parametru { } public Cuptor(string model, string culoare) //doi parametri { } } |
Ce se întâmplă când nu furnizăm deloc un constructor? Ca și în multe alte cazuri, compilatorul va crea un constructor implicit pentru noi, care este gol, nu are parametri și nici nu conține un cod în corpul său, și care nu face nimic altceva decât să inițializeze câmpurile noastre cu valoarea implicită a tipului lor. Acest tip de constructor se numește constructor implicit prestabilit. Aceasta înseamnă că nu este obligatoriu să creați o clasă cu un constructor, dacă nu aveți nevoie de un cod de inițializare la instanțierea clasei voastre. În cele din urmă, trebuie să știți că un constructor implicit prestabilit nu are aceeași semnătură ca un constructor fără parametri! Un constructor implicit prestabilit va avea întotdeauna nivelul de acces protected sau public (vom afla despre acest lucru în viitor) – în funcție de nivelul de acces al clasei în sine, în timp ce un constructor fără parametri declarat în mod specific de noi va avea orice nivel de acces îi oferim acestuia.
În următoarea lecție, vom vedea și modul de a apela constructorii, deoarece nu pot fi apelați în modul obișnuit de apelare al metodelor.
În concluzie, constructorul este punctul de intrare al clasei noastre, așa cum metoda Main() este punctul de intrare al programului nostru: este primul lucru care este executat atunci când se realizează instanțializarea unei clase. Dacă vrem să executăm automat un cod atunci când creăm o copie a unei clase, o putem facem folosind constructori.
Tags: clasă, constructori, OOP
