- Clasa este structura de baza a C#
- Clasa serveste ca temelie pentru POO.
- In clasa se determina datle si codul.
1. Notiuni principale ale clasei
- Clasa este un sablon, dupa care se determina forma obiectului. In clasa se determina datele si codul care va opera cu aceste date. Obiectele sunt exemplare ale clasei. Rezulta ca clasa este o descriere a metodei de creare a obiectelor.
- Clasa este o abstractie logica
- Fizic clasa apare in memoria operativa daor dupa crearea obiectelor.
2. Forma comuna de determinare a clasei
- La crearea clasei se declara datele si codul care operaza cu datele. Datele se contin in membrii-date, iar codul in functiile-membre
- In C# sunt citeva tipuri de membrii-date(cimpuri care contine variabilele exemplarului cit si variabilele statice) si functiile-membre(metode, constructori,destructori, indexatori,evenimente, operatori si proprietati).
- Clasa se creaza cu ajutorul cuvintului cheie class
class nume_clasa {
//variabilele exemplrarului
acces tip var1;
//.....
acces tip varN;
//metodele
acces tip_returnat metoda1 ( parametri ) { //corpul metodei }
//...........
acces tip_returnat metodaN ( parametri ) { //corpul metodei }
}
- Specificatorul de acces determina tipul de acces permis (dacalipseste se considera private)
- Membrii private pot fi folositi doar de alti membri ai clasei
- public - acces permis din afara clasei
- Clasa trebuie sa determine doar o singura entitate logica
3. Determinare clasa
- Pentru a demonstra clasele pe exemplu concret, vom vrea pe etape o clasa, care incapsuleaza informatia despre constructii, caselor, depozitelor et.
- In aceasta clasa (denumita Building) se vor pastra trei elemente cu informatie: numarul de etaje, suprafata totala si numarul de locatari.
- Mai jos este prima varianta a clase Building. In ea sunt determinate trei variabile: Floors, Area si Occupants.
class Building {
public int Floors; // numarul de etaje
public int Area; // suprafata totala
public int Occupants; // numarul de locatari
}
- Clasa nu are metode (este compusa doar din date).
- Forma generala de declarare al variabilelor: acces tip nume_variabila;
- Creare clasa inseamna crearea unui nou tip de date (in cazul nostru tipul Building). Cu ajutorul acestui nume se pot declara obiecte de tip Building. Clasa doar descrie tipul de date, nu creaza obiecte. Pentru a crea obiecte se formeaza expresia de tipul
Building house = new Building(); //creare obiect de tip Building
Dupa executarea ecestui operator obiectul house devine exemplar al clasei Building. De fiecare data cind se primeste un exemplar al clasei, se creaza de asemenea si un obiect care contine o copie proprie a fiecarei variabile al exemplarului clasei. Rezulta ca fiecare obiect de tip Building va contine copiile proprii variabilelor exemplarelor Floors,Area si Occupants. Pentru a accesa aceste variabile ne folosim de operatorul de acces la membrii claselor care se numeste operatorul-punct.Acest operator leaga numele obiectului cu numele membrului clasei. Exemplu: atribuirea valorii 2 variabilei Floors al obiectului house se produce in felul urmator:
house.Floors = 2;
- Operatorul-punct ofera posibilitatea de accesa variabilele cit si metodele clasei.
- Exemplu:
//folosire clasa Building
using System;
class Building
{
public int Floors; // numarul de etaje
public int Area; // suprafata totala
public int Occupants; // numarul de locatari
}
//in aceasta clasa se declara obiecte de tip Building
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building(); // creare obiect de tip Building
int areaPP; //suprafata pentru o persoana
//atribuire valori cimpurilor obiectului house
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
//calculare suprafata pentru o persoana
areaPP = house.Area / house.Occupants;
Console.Write("Casa are: \n " +
house.Floors + " etaje\n " +
house.Occupants + " locatari\n " +
house.Area +
" metri patrati din suprafata totala\n " +
areaPP + " revin la o persoana");
Console.ReadKey(true);
}
}
}
Aceasta programa contine doua clase: Bilding si BuildingDemo. In clasa BuildingDemo la inceput se creaza exemplarul house al clasei Building cu ajutorul metodei Main(), pe urma in coul metodei Main() se obtine accesul la variabilele exemplarului house pentru a i se atribui valori si pentru folosirea ulterioara a acestor valori. Clasele sunt total diferite. Clasa BuildingDemo are acces la membrii clasei Build pentru ca acestea sunt declarate public.
- Fiecare obiect are copiile proprii ale variabilelor exemplarului determinate in clasa (continutul variabilelor intr-un obiect poate fi diferit de alt obiect). Intre obiecte nu exista nici o legatra, doar ca sunt obiecte al uneia si aceiasi clasa
Exemplu:
//creare doua obiecte clasa Building
using System;
class Building
{
public int Floors; // numarul de etaje
public int Area; // suprafata totala
public int Occupants; // numarul de locatari
}
//in aceasta clasa se declara obiecte de tip Building
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building(); // creare obiect de tip Building
Building office = new Building(); // creare obiect de tip Building
int areaPP; //suprafata pentru o persoana
//atribuire valori cimpurilor obiectului house
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
//atribuire valori cimpurilor obiectului office
office.Occupants = 25;
office.Area = 4200;
office.Floors = 3;
//calculare suprafata pentru o persoana in casa de locuit
areaPP = house.Area / house.Occupants;
Console.Write("Casa are: \n " +
house.Floors + " etaje\n " +
house.Occupants + " locatari\n " +
house.Area +
" metri patrati suprafata totala\n " +
areaPP + " revin la o persoana");
//calculare suprafata pentru o persoana in oficiu
areaPP = office.Area / office.Occupants;
Console.Write("\n\nOficiul are: \n " +
office.Floors + " etaje\n " +
office.Occupants + " locatari\n " +
office.Area +
" metri patrati suprafata totala\n " +
areaPP + " revin la o persoana");
Console.ReadKey(true);
}
}
}
4. Creare obiecte
- Building house = new Building(); Acest rind jndeplineste trei functii:
1 - se declara variabila house, dependenta de clasa Building. Aceasta variabila nu este obiect, este doar o variabila care poate face referinta la un obiect.
2 - Se creaza copia concreta a obiectului. Acest lucru se face cu operatorul new
3 - Variabilei house i se atribuie referinta la obiect. In asa fel variabila house face referinta la un obiect de tip Building.
- Opratorul new aloca in mod dinamic memoria pentru si retunreaza referinta la el, care se pastreaza in variabila
- In C# pentru obiecte trebuie de alocat dinamic memoria
- Declararea variabilelor se poate de separat de crearea obiectului la care face referinta:
Building house; // declara referinta la obiect
house = new Building(); //aloca memorie pentru obiect de tip Building
In primul rind se declara variabila house ca referinta la obiect de tip Building. Prin urmare house este o variabila care se poate refrei la un obiect, dar nu este obiect. In rindul doi se craza un obiect nou de tip Building, si refernia la el se atribuie variabilei house. In rezultat variabila house devine legata de obiectul dat
- Faptul ca obiectele claselor sunt accesibile prin referinta, explica de ce clasele se numesc tipuri referinta. Cea mai mare diferenta intre tipul valoric si tipul referinta consta in ce anume contin variabilele acestor tipuri. Variabilele de tip valoarea contin valori concrete
int x;
x = 10; // variabla x contine valoarea 10, pentru ca ea este de tip int, care la rindul sau este tip valoric
- Iar in rindul: Building house = new Building (); // variabila house contine doar referinta la obiect
5. Variabile de tip referinta si atribuirea
- Cind o variabila referinta la obiect se atrubuie alteia, variabila care se afla in stinga operatorului de atribuire face referinta la acelasi obiect, la care se refera si variabila din partea drepata a operatorului de atribuire. Obiectul nu se copie.
Building house = new Building ();
Building house2 = house1;
Variabilele house1 si house2 fac referinta la acelasi obiect, nu au altfel de legatura intre ele.
6. Metodele
- Sunt subprograme, care manipuleaza cu datele determinate in clase, de multe ori metodele reprezinta accesul la aceste date. Alte parti ale programei interactioneaza cu clasa prin intermediul metodelor
- Metoda contine unul sau mai multi operatori. trebuie sa execute o singura functie. Are nume propriu
- Forma generala de declarare a metodei
acces tipul_returnat nume (lista_parametri){
//corpul metodei
}
acces - este modificatorul de acces care determina parti ale programei din care se poate de apleat metoda
tipul_returnat - tipul de date returna de metoda, trebuie sa fie valid
nume - nume concret dat metodei
lista_parametri - este o sucesiune de perechi formate din tip si identificatori separati prin virgula. Parametri reprezinta variabile, denumite argumente, transmise metodei la apelul ei.
7. Adaugare metida clasei Building
- Metodele manipuleaza cu datele si ofera acce la ele.
EX:
// adaugare metoda in clasa Building
using System;
class Building
{
public int Floors; // numarul de etaje
public int Area; // suprafata totala
public int Occupants; // numarul de locatari
//calcul suprafata pentru o persoana
public void AreaPerPerson() {
Console.WriteLine("din suprafata totala " + Area / Occupants +
" revin la o persoana ");
}
}
//folosire metoda AreaPerPerson()
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building(); // creare obiect de tip Building
Building office = new Building(); // creare obiect de tip Building
int areaPP; //suprafata pentru o persoana
//atribuire valori cimpurilor obiectului house
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
//atribuire valori cimpurilor obiectului office
office.Occupants = 25;
office.Area = 4200;
office.Floors = 3;
Console.Write("Casa are: \n " +
house.Floors + " etaje\n " +
house.Occupants + " locatari\n " +
house.Area +
" metri patrati \n ");
house.AreaPerPerson();
Console.WriteLine();
Console.Write("\n\nOficiul are: \n " +
office.Floors + " etaje\n " +
office.Occupants + " locatari\n " +
office.Area +
" metri patrati \n ");
office.AreaPerPerson();
Console.ReadKey(true);
}
}
}
- Examinam elementele principale ale acestei clase incepind cu metoda AreaPerPerson(): primul ei rind este
public void AreaPerPerson() {
In acest rind se declara metoda numita AreaPerPerson si care nu are parametri. Este de tip public, asta inseamna ca se poate de apelat din orice loc al programei. Metoda returneaza void (nu returneza nimic portiunii de cod care o apeleaza). Rindul analizat se termina cu acolada, care deschide corpul metodei.
Corpul metodei contine doar un singur operator
Console.WriteLine("din suprafata totala " + Area / Occupants +
" revin la o persoana ");
Acest operator afiseaza suprafata pentru opersoana,care rezulta din impartirea supragetei totale (variabila Area) la numarul de locatari (variabila Occupants). Deoarce fiecare obiect de tip Building are copia proprie ale variabilelor Area si Occupants, atunci la apelarea metodei AreaPerPerson() in calcul se folosesc copiile variabilelor corespunzator fiecarui obiect.
Metoda AreaPerPerson() se termina cu acolada . Cind se intilneste aceasta acolada, controlul revine codului care a apelat metoda
}
- Analizam rindul din metoda Main():
house.AreaPerPerson();
In acest rind se apeleaza metoda AreaPerPerson() pentru obiectuk house. Aceasta inseamna ca metoda se apeleaza in dependenta de obiectul la care face referinta variabila house, pentru acest scop serveste operatorul-punct. Cind metoda AreaPerPerson() se apeleaza, acesteia i se transmite controlul asupra programei. Iar la terminarea ei, controlul revine codului ce urmeaza dupa apelarea metodei.
In acest caz in rezultatul apelarii house.AreaPerPerson() se afiseaza suprafata pentru o persoana, determinat in obiectul house.Analog si in rezultatul apelului oficce.AreaPerPerson() se afiseaza suprafata pentru o persoana, determinat in obiectul oficee.
8. Returnare valoare
- Metode ce returneaza void sunt des utilizate in programare, dar foarte multe metode returneaza valori concrete. Cpacitatea de a returna valoare este un din cele mai utile proprietati ale metodei. Returnare de valori se foloseste in diverse scopuri. In unele cazuri valoarea returnata este rezultatul unui calcul, in alte cazuri - poate indica daca metoda s-a terminat cu succes sau nu, si in ultimul caz contine codul de stare.
- Pentru a returna valoare de metoda in codul care a apelat-o se foloseste urmatoarea forma al operatorului return: return valoare; unde valoare - este o valoare concreta returnata.
EX:
// returnare valoare din metoda AreaPerPerson
using System;
class Building
{
public int Floors; // numarul de etaje
public int Area; // suprafata totala
public int Occupants; // numarul de locatari
//calcul suprafata pentru o persoana
public int AreaPerPerson()
{
return Area / Occupants;
/*Console.WriteLine("din suprafata totala " + Area / Occupants +
" revin la o persoana ");*/
}
}
//folosire valoare, returnata de metoda AreaPerPerson()
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building(); // creare obiect de tip Building
Building office = new Building(); // creare obiect de tip Building
int areaPP; // suprafata pentru o persoana
//atribuire valori cimpurilor obiectului house
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
//atribuire valori cimpurilor obiectului office
office.Occupants = 25;
office.Area = 4200;
office.Floors = 3;
//calculare suprafata pentru o persoana in house
areaPP = house.AreaPerPerson();
Console.Write("Casa are: \n " +
house.Floors + " etaje\n " +
house.Occupants + " locatari\n " +
house.Area +
" metri patrati, din care \n " +
areaPP + " revin unei persoane");
Console.WriteLine();
//calcul suprafata pentru o persoana in oficiu
areaPP = office.AreaPerPerson();
Console.Write("\n\nOficiul are: \n " +
office.Floors + " etaje\n " +
office.Occupants + " locatari\n " +
office.Area +
" metri patrati, din care\n " +
areaPP + "revine unei persoane");
office.AreaPerPerson();
Console.ReadKey(true);
}
}
}
Aceasta programa da acelasi rezultat ca la punctele anterioare. Cind se apeleaza metoda AreaPerPerson(); ea se indica in partea drepta al operatorului de atribuire. In partea stinga al acestui operator se indica variabila, careia i se atribuie valoarea returnata de metoda AreaPerPerson();. Prin urmare dupa executarea operatorului areaPP = house.AreaPerPerson(); in variabila areaPP se pastreaza marimea suprafetei pentru o persoana in casa de locuit (obiectul house). Metoda AreaPerPerson(); returneaza acuma tipul int. Acest lucru inseamna ca ea va returna o valoarea intreaga codului care a apelat-o. Tipul returnat de metode are foarte mare insemnatate, pentru ca tipul de date returnat de metoda trebuie sa fie compatibil cu tipul de date indicat in metoda. Daca metoda trebuie sa returneze date de tip double, atunci tipul returnat al metodei trebuie sa fie neaparat double. Programa de mai sus este corecta, dar nu este efectiva. Se poate in general ca variabila areaPP sa nu fie folosita, indicind metoda AreaPerPerson(); in operatorul in care se apeleaza metoda WriteLine():
Console.Write("\n\nOficiul are: \n " +
office.Floors + " etaje\n " +
office.Occupants + " locatari\n " +
office.Area +
" metri patrati, din care\n " +
office.AreaPerPerson() + "revine unei persoane");
In acest caz la executarea operatorului care contine metoda WriteLine(), automat se apeleaza metoda office.AreaPerPerson(), iar valoarea returnata de aceasta se transmite metodei WriteLine(). In afara de aceasta apelul metodei AreaPerPerson() se poate de folosit ori de cite ori este nevoie de marimea suprafetei pentru o persoana pentru un obiect concret de tip Building. Spre exemplu in operatorul de mai jos se compara marimile suprafetei pentru o persoana la doua cladiri:
if ( b1.AreaPerPerson ( ) > b2.AreaPerPerson ( ) )
Console.WriteLine ( "In cladirea b1 este mai mult loc pentru fiecare peroana");
9. Folosire parametri
- La apelul unei metode, acesteia i se poate de dat una sau mai multe valori. Valoarea transmisa metodei se numeste argument. Iar variabla care primeste valoarea se numeste parametru formal, sau parametru. Parametrii se declara in paranteze dupa numele metodei. Sintaxa este aceiasi ca la variabile. Domeniul de vizibilitate al parametrilor este metoda. Excluzind situatii speciale de transmitere argumente metodei, parametrii actioneaza la fel ca si oricare alte variabile.
- Mai jos este un exemplu de programa in care se demonstreaza folosirea parametrilor. In clasa ChkNum se foloseste metoda IsPrime(), care returneaza valoarea true, daca ei i se transmite un numar prim. In caz contrar returneaza false. Prin urmare, tipul returnat pentru metoda IsPrime() este bool.
EX:
// folosire parametri
using System;
class ChkNum
{
// Returneaza valoarea true, daca valoarea
// parametrului x este numar prim
public bool IsPrime(int x) {
if (x <= 1) return false;
for (int i = 2; i <= x / i; i++)
if ((x % i) == 0) return false;
return true;
}
}
namespace UseParameters
{
class Program
{
static void Main(string[] args)
{
ChkNum ob = new ChkNum();
for (int i = 2; i < 10; i++)
if (ob.IsPrime(i)) Console.WriteLine(i + " numar prim.");
else Console.WriteLine(i + " numar neprim");
Console.ReadKey(true);
}
}
}
In aceasta programa metoda IsPrime() se apeleaza de opt ori, de fiecare data i se transmite alta valoare. Analiza cum se apeleaza metoda IsPrime() : argumentul se indica in parantezele metodei. Cind metoda IsPrime() este apelata pentru prima data, i se transmite valoarea 2. Prin urmare cind aceasta metoda incepe sa se execute, parametrul ei x primeste valoarea 2.La al doilea apel x primeste valoarea 3, la al treilea apel - 4 etc. In asa fel valorile care se transmit metodei IsPrime() in calitate de argument la apelul ei,reprezinta, valoarea care o primeste parametrul x.
- Metodele pot avea mai multi parametri separati prin virgula. In calitate de exemplu mai jos prezentam clasa ChkNum, in care este adaugata metoda LeastComFactor(), care returneaza cel mai mic multiplu comun a doua argumente. Cu alte cuvinte, aceasta metoda returneaza cel mai mic numar, la care ambele argumente se impart exact
EX:
// adaugare metoda, care primeste doua argumente
using System;
class ChkNum
{
// Returneaza valoarea true, daca valoarea
// parametrului x este numar prim
public bool IsPrime(int x) {
if (x <= 1) return false;
for (int i = 2; i <= x / i; i++)
if ((x % i) == 0) return false;
return true;
}
//returneaza cel mai mic multiplu comun
public int LeastComfactor(int a, int b) {
int max;
if (IsPrime(a) || IsPrime(b)) return 1;
max = a < b ? a : b;
for (int i = 2; i <= max / 2; i++)
if (((a % i) == 0) && ((b % i) == 0)) return i;
return 1;
}
}
namespace ParmDemo
{
class Program
{
static void Main(string[] args)
{
ChkNum ob = new ChkNum();
int a, b;
for (int i = 2; i < 10; i++)
if (ob.IsPrime(i)) Console.WriteLine(i + " numar prim.");
else Console.WriteLine(i + " numar neprim");
a = 7;
b = 8;
Console.WriteLine("CMMC al numerelor " +
a + " si" + b + " este " +
ob.LeastComfactor(a, b));
a = 100;
b = 8;
Console.WriteLine("CMMC al numerelor " +
a + " si" + b + " este " +
ob.LeastComfactor(a, b));
a = 100;
b = 75;
Console.WriteLine("CMMC al numerelor " +
a + " si" + b + " este " +
ob.LeastComfactor(a, b));
Console.ReadKey(true);
}
}
}
Cind se apeleaza metoda LeastComfactor(), argumentele ei se despart prin virgula.
- Daca in metoda se folosesc mai multi parametri, atunci pentru fiecare din ei se indica tipul: int MyMeth(int a, double b, float c) { }.
10. Adaugare metoda cu parametri clasei Building
- Cu ajutorul metodelor partametrizate se poate de adaugat clasei Building noi mijloace, care permit calcularea numarul maxim de locatari deducind din determinarea suprafetei minime pentru o persoana:
EX.
/*
Adaugare metoda cu parametri, care calculeaza
numarul maxim de persoane, ce pot acupa cladirea,
deducind din suprafata minima data pentru o persoana
*/
using System;
class Building {
public int Floors; // Numarul de etaje
public int Area; //suprafata totala
public int Occupants; //numarul de locatari
//returneaza numarul maxim de persoane, care sunt in cladire
//deducind din suprafata minima data pentru o persoana
public int MaxOccupant(int minArea) {
return Area / minArea;
}
}
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building();
Building office = new Building();
//atribuire valori obiectului house
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
//atribuire valori obiectului house
office.Occupants = 25;
office.Area = 4200;
office.Floors = 3;
Console.WriteLine(" Numarul maxim de persoane in casa. \n" +
" daca la fiecare revine " +
300 + " metri patrati: " +
house.MaxOccupant(300));
Console.WriteLine();
Console.WriteLine(" Numarul maxim de persoane in oficiu \n" +
" daca la fiecare revine " +
300 + " metri patrati: " +
office.MaxOccupant(300));
Console.ReadKey(true);
}
}
}
11. Excludere cod inaccesibil
- La crearea metodelor trebuie de exclus situatia , in care o prtiune de cod nu poate fi executata defel. Acest cod se considare neaccesibil si se considera incorect. Daca cream o metoda ,care contine astfel de cod compilatorul va genera un mesaj corspunzator:
- Analizam urmatorul cod:
public void MyMeth(){
char a, b;
//...
if(a==b){
Console.WriteLine("egal");
return;
}
else{
Console.WriteLine("nu este egal");
return;
}
Console.WriteLine("acesta este cod inaccesibil");
}
In acest exemplu iesirea din metoda MyMeth() intotdeauna se petrece inainte de ultimul operator,care apeleaza metoda WrieLine(). Daca incercam sa compilam acest cod, va fi generat un mesaj de preintimpinare. In general codul inaccesibil se considera eroare logica, si de aceea mesajele de preintimpinare trebuie luate in serios.
12. Constructorii
- In programele de mai sus variabilele exemplarului fiecarui obiect de tip Building trbuie sa-l initializam manual, folosind operatorii
house.Occupants = 4;
house.Area = 2500;
house.Floors = 2;
Asa metoda de obiecei nu se foloseste in programarea profesionista. In afara de aceasta metoda respectiva are foalte multe erori(putem uita unul din cimpuri). Exista o metoda mai buna de a rezolva aceasta problema: folosirea constructorilor.
- Constructorul initializeaza obiectul la crearea acestuia. Constructorul are nume, ca si clasa, si din punct de vedere al sintaxei seamana cu metodele. Constructorul nu are tip returnat, indicat concret. Forma generala a constructorului este:
acces nume_clasa (lista_parametri) {
// corpul constructorului
}
- Constructorul se foloseste pentru a da valori initiale variabilelor exemplarelor, determinate in clase, sau pentru indeplinirea altor proceduri, care trebuie pentru crearea obiectului. In afara de aceasta, accesul de obicei reprezinta modificatorul de acces de tip public, deoarece constructorii cel mai des sunt apelati in clase. Lista de parametri poate fi goala, sau cu unul sau mai multi parametri.
- Toate clasele au construcori, independent daca ii declaram noi sau nu, deoarece in C# automat se creaza un constructor, care initializeaza toate variabilele cu valori bydefault. Pentru majoritatea tipurilor de date valoarea aceasta este zero, pentru tipul bool - false, iat pentru tipuri referinta - valoarea nul.
- Din moment ce declaram un construtor propriu, constructoul bydefault nu se mai foloseste
EX. Folosire constructor
//constructor simplu
using System;
class MyClass {
public int x;
public MyClass() {
x = 10;
}
}
namespace Constructor
{
class Program
{
static void Main(string[] args)
{
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
Console.WriteLine(t1.x + " " + t2.x);
Console.ReadKey(true);
}
}
}
In acest exemplu constructoul clasei MyClass are forma
public MyClass() {
x = 10;
}
Acest constructor este determinat ca public. Pentru ca el trebuie sa poata fi apelat de codul care se afla in afara clasei. In acest construcotr variabilei exemlarului claseii MyClass i se atribuie valoarea 10. El se apeleaza in operatorul new la crearea obiectului. De exemplu in rindul urmator:
MyClass t1 = new MyClass();
constructorul MyClass() se apeleaza pentru obiectul t1, atribuinduise variabilei exemplarului t1.x valoarea 10. Acelas lucru se intimpla si pentru obiectul t2. Dupa construire variabila t2.x va avea aceiasi valoare, adica 10. In asa fel in urma executarii codului de mai sus obtinem rezultatul 10 10.
13. Constructorii cu parametri
- In cele mai dese cazuri constructorii trebuie sa aiba unul sau mai multi parametri. In constructor parametrii se introduc in acelas mod ca la metode. Pentru asta este destul doar de declarat parametrii in paranteze dupa numele constructorului
- EX.:
//constructor cu parametri
using System;
class MyClass {
public int x;
public MyClass(int i) {
x = i;
}
}
namespace parmConsDemo
{
class Program
{
static void Main(string[] args)
{
MyClass t1 = new MyClass(10);
MyClass t2 = new MyClass(88);
Console.WriteLine(t1.x + " " + t2.x);
Console.ReadKey(true);
}
}
}
La executare se afiseaza urmatorul rezultat: 10 88
- La aceasta varianta al constructorului MyClass() este determinat parametrul i, cu ajutorul caruia se initializeaza variabila exemlarului x. De aceia la executarea urmatorului rind de cod: MyClass t1 = new MyClass(10); parametrului i, i se transmite valoarea, care apoi se atribuie variabilei x.
14. Adaugare construcor la clasa Building
- Clasa Building se poate de pefectionat, adaugind la ea un constructor ,care automat va initializa cumpurile Floors, Area si Occupants la crearea obiectului. De atras atenita la felul cum se creaza obiectele clasei Building.
EX.:
/*
Adaugare constructor clasei Building
*/
using System;
class Building
{
public int Floors; // Numarul de etaje
public int Area; //suprafata totala
public int Occupants; //numarul de locatari
//constructor cu parametri pentru clasa Building
public Building(int f, int a, int o) {
Floors = f;
Area = a;
Occupants = o;
}
//returneaza suprafata pentru o persoana
public int AreaPerPerson() { return Area / Occupants; }
//returneaza numarul maxim de persoane, care sunt in cladire
//deducind din suprafata minima data pentru o persoana
public int MaxOccupant(int minArea) { return Area / minArea; }
}
//folosire constructor cu parametri ai clasei Building
namespace BuildingDemo
{
class Program
{
static void Main(string[] args)
{
Building house = new Building(2, 2500, 4);
Building office = new Building(3, 4200, 25);
Console.WriteLine(" Numarul maxim de persoane in casa. \n" +
" daca la fiecare revine " +
300 + " metri patrati: " +
house.MaxOccupant(300));
Console.WriteLine();
Console.WriteLine(" Numarul maxim de persoane in oficiu \n" +
" daca la fiecare revine " +
300 + " metri patrati: " +
office.MaxOccupant(300));
Console.ReadKey(true);
}
}
}
- Ambele obiecte, house si office, au fost initializate de constructorul Building(), la crearea acestor obiecte in corespundere cu parametrii fiecaruia. De exemplu:
Building house = new Building(2, 2500, 4);
constructorului Building(), i se transmit valorile 2, 2500 si 4 la crearea noului obiect. Prin urmare in copiile variabilelor exemplarelor Floors, Area si Occupants ale obiectului house vor fi pastrate valorile 2, 2500 si 4 corespunzator.