Clase și obiecte în C#
C# este un limbaj de programare orientat pe obiecte, ceea ce înseamnă că putem reprezenta o aplicație C# ca un set de obiecte interconectate care interacționează între ele. Un obiect este o instanță a unei clase, iar clasa este un tip de date definit de utilizator care descrie structura și comportamentul obiectelor.
O clasă în C# este un șablon pentru obiecte, care definește datele și comportamentele pe care obiectele de acest tip le vor avea. O analogie ar fi aceea că toți avem o anumită reprezentare a unui om, care are un nume, o vârstă și alte caracteristici. Acest șablon poate fi numit clasă. Un om concret, cu un anumit nume și o anumită vârstă, este un obiect (sau instanță) al acestei clase.
Anterior, am folosit deja clase. De exemplu, tipul string, care reprezintă un șir de caractere, este de fapt o clasă. Sau, de exemplu, clasa Console, care are metoda WriteLine() ce afișează informații în consolă. Acum vom vedea cum putem defini propriile noastre clase.
Clasele sunt definite folosind cuvântul cheie class, urmat de numele clasei și apoi de un set de acolade care conțin definițiile membrilor clasei (câmpuri, metode etc.).
class nume_clasă
{
// conținutul clasei
}După cuvântul class urmează numele clasei, iar apoi, între acolade, se definește conținutul clasei.
De exemplu, să definim în fișierul Program.cs clasa Person, care va reprezenta o persoană:
class Person
{
}
Începând cu versiunea C# 12, dacă o clasă are o definiție goală, atunci acoladele după numele tipului pot fi omise:
class Person;Cu toate acestea, o astfel de clasă nu este foarte relevantă, așa că vom adăuga în ea ceva funcționalitate.
Câmpuri și metode ale clasei
Clasa poate stoca anumite date. Pentru stocarea datelor în clasă se folosesc câmpurile. Practic, câmpurile clasei sunt variabile definite la nivel de clasă.
În plus, clasa poate defini un anumit comportament sau acțiuni executabile. Pentru definirea comportamentului în clasă se folosesc metodele.
Așadar, să adăugăm în clasa Person câmpuri și metode:
class Person
{
public string name = "Undefined"; // nume
public int age; // varsta
public void Print()
{
Console.WriteLine($"Nume: {name} Varsta: {age}");
}
}În acest caz, în clasa Person este definit un câmp name, care stochează numele, și un câmp age, care stochează vârsta persoanei. Spre deosebire de variabilele definite în metode, câmpurile clasei pot avea modificatori, care sunt indicați înaintea câmpului. Astfel, în acest caz, pentru ca toate câmpurile să fie accesibile în afara clasei Person, câmpurile sunt definite cu modificatorul public.
La definirea câmpurilor putem să le atribuim anumite valori, ca în exemplul de mai sus în cazul variabilei name. Dacă câmpurile clasei nu sunt inițializate, atunci ele primesc valori implicite. Pentru variabilele de tip numeric, aceasta este valoarea 0.
De asemenea, în clasa Person este definită metoda Print(). Metodele clasei au acces la câmpurile acesteia, iar în acest caz ne referim la câmpurile clasei name și age pentru a le afișa valorile pe consolă. Și pentru ca această metodă să fie vizibilă în afara clasei, ea este de asemenea definită cu modificatorul public.
Crearea unui obiect al clasei
După definirea clasei putem crea obiecte ale acesteia. Pentru crearea obiectului se folosesc constructorii. De fapt, constructorii reprezintă metode speciale, care se numesc la fel ca și clasa și care sunt apelate la crearea unui nou obiect al clasei și realizează inițializarea obiectului. Sintaxa generală a apelului constructorului:
new constructor_clasă(parametri_constructor);Mai întâi vine operatorul new, care alocă memorie pentru obiect, iar după el urmează apelul constructorului.
Dacă în clasă nu este definit niciun constructor (ca în cazul clasei noastre Person), atunci pentru această clasă se creează automat un constructor implicit gol, care nu acceptă niciun parametru.
Acum să creăm un obiect al clasei Person:
Person tom = new Person(); // crearea unui obiect al clasei Person
// definirea clasei Person
class Person
{
public string name = "Undefined";
public int age;
public void Print()
{
Console.WriteLine($"Nume: {name} Vârsta: {age}");
}
}
Pentru crearea obiectului Person se folosește expresia new Person(). În final, după executarea acestei expresii, în memorie va fi alocată o zonă unde vor fi stocate toate datele obiectului Person. Iar variabila tom va primi o referință la obiectul creat și prin această variabilă putem utiliza obiectul și să accesăm funcționalitatea acestuia.
Accesarea funcționalității clasei
Pentru accesarea funcționalității clasei - câmpuri, metode (precum și alte elemente ale clasei) se folosește notația prin punct - după obiectul clasei se pune un punct, iar apoi elementul clasei:
obiect.câmp_clasă
obiect.metodă_clasă(parametri_metodă)De exemplu, să ne referim la câmpurile și metodele obiectului Person:
Person tom = new Person(); // crearea unui obiect al clasei Person
// Obținem valorile câmpurilor în variabile
string personName = tom.name;
int personAge = tom.age;
Console.WriteLine($"Nume: {personName} Vârsta{personAge}"); // Nume: Undefined Vârsta: 0
// setăm noi valori pentru câmpuri
tom.name = "Tom";
tom.age = 37;
// ne referim la metoda Print
tom.Print(); // Nume: Tom Vârsta: 37
class Person
{
public string name = "Undefined";
public int age;
public void Print()
{
Console.WriteLine($"Nume: {name} Vârsta: {age}");
}
}Output-ul consolei acestui program:
Nume: Undefined Vârsta: 0
Nume: Tom Vârsta: 37Adăugarea unei clase
De obicei, clasele sunt plasate în fișiere separate. Adesea, pentru o clasă este destinat un singur fișier. Dacă lucrăm la un proiect în afara mediului Visual Studio, utilizând .NET CLI, atunci este suficient să adăugăm un nou fișier de clasă în folderul proiectului. De exemplu, să adăugăm un nou fișier, pe care îl numim Person.cs și în care definim următorul cod:
class Person
{
public string name = "Undefined";
public void Print()
{
Console.WriteLine($"Person {name}");
}
}Aici este definită clasa Person cu un câmp name și o metodă Print.
În fișierul Program.cs, care reprezintă fișierul principal al programului, utilizăm clasa Person:
Person tom = new Person();
tom.name = "Tom";
tom.Print(); // Person Tom
Visual Studio oferă implicit șabloane încorporate pentru adăugarea unei clase. Pentru a adăuga o clasă, apăsăm în Visual Studio pe numele proiectului cu butonul drept al mouse-ului:
În meniul contextual care apare, selectăm opțiunea Add -> New Item... (sau Add -> Class...)
În fereastra care se deschide pentru adăugarea unui nou element, ne asigurăm că în partea centrală cu șabloane de elemente este selectată opțiunea Class. Iar în partea de jos a ferestrei, în câmpul Name, introducem numele clasei adăugate - să zicem că se va numi Person:
Ca nume al clasei se poate introduce atât Person, cât și Person.cs. Iar după apăsarea butonului de adăugare, în proiect va fi adăugată o nouă clasă, în care putem defini același cod și să o utilizăm în fișierul Program.cs.
Astfel, putem defini clase în fișiere separate și să le folosim în program.