Programarea orientată pe obiecte este una dintre cele mai populare paradigme de programare. Acest lucru se datorează faptului că modelează atât datele, cât și funcțiile și vă permite să gândiți în termeni de obiecte din lumea reală. Clasele sunt un aspect fundamental al programării orientate pe obiecte, deoarece oferă planul de care aveți nevoie pentru a crea obiecte.

C# este un limbaj popular de programare multi-paradigma, care folosește paradigma orientată pe obiecte. În acest articol, veți învăța cum să creați și să utilizați clase în C#.

Crearea unei declarații de clasă

În C#, o clasă este un tip de referință, care va conține nul valoare până când creați un nou obiect al clasei. Pentru a crea o nouă clasă în C# veți avea nevoie de mai multe componente:

  • Un modificator de acces.
  • The clasă cuvânt cheie.
  • Numele pe care doriți să-l atribuiți clasei.
  • O pereche de acolade deschise și închise (care vor include atributele, constructorii și metodele clasei). 
intern clasăClient{ }

Codul de mai sus creează o nouă clasă care este accesibilă de către alte clase din același ansamblu (fișier de compilare). C# are exact șase modificatori de acces pe care îi puteți folosi pentru a controla nivelurile de accesibilitate ale claselor, variabilelor și metodelor dvs. Cei șase modificatori de acces sunt:

instagram viewer

  • public: fiecare clasă (indiferent de ansamblul său) poate accesa clasa publică și membrii săi publici (atribute, constructori și metode).
  • privat: doar clasa privată și membrii săi o pot accesa.
  • protejat: numai clasele derivate (clasele pentru copii și nepoți) pot accesa clasa protejată.
  • intern: numai clasele din același ansamblu pot accesa clasa internă.
  • protejat intern: numai clasele din același ansamblu sau o clasă derivată dintr-un alt ansamblu pot accesa clasa internă protejată.
  • privat protejat: numai clasele derivate din același ansamblu pot accesa clasa privată protejată.

Declararea și accesarea atributelor

Atributele sunt elementele de bază ale claselor pe care le creați. Acestea dețin date sensibile și, de obicei, au un modificator de acces privat sau protejat. Prin urmare, pentru a accesa aceste clase din clase externe, ar trebui să utilizați accesori și mutatori (getters și setters).

C# vă permite să vă declarați atributele, mutatorii și accesorii, după cum urmează:

intern clasăClient
{
// atribute
privatint Numar de identificare;
privat șir Nume;
privatdubla Total;
// setters
publicgolSetIdNumber(int Numar de identificare){ acest.IdNumber = IdNumber; }
publicgolPune un nume(Nume șir){ acest.Nume = Nume; }
publicgolSetTotal(dubla Total){ acest.Total = Total; }
// getters
publicintGetIdNumber(){ întoarcereacest.Numar de identificare; }
public şir GetName(){ întoarcereacest.Nume; }
publicdublaGetTotal(){ întoarcereacest.Total; }
}

Alte populare limbaje orientate pe obiecte utilizați și abordarea de mai sus. De fapt, dacă vrei creați clase Java, va trebui să utilizați structura de mai sus. Cu toate acestea, C# are acum o modalitate mai ușoară de a crea atribute și accesorii. În C#, această clasă are aceeași funcție ca cea de mai sus:

intern clasăClient
{
 public int IdNumber { obține; a stabilit; }
 șir public Nume { obține; a stabilit; }
 public dublu Total { obține; a stabilit; }
}

Clasa de mai sus conține ceea ce numește C# proprietăți, care este o combinație de atribute (câmpuri) și metode. Cu proprietăți, puteți reduce declarația de atribut, mutatorii și codul de accesorii la jumătate.

Declararea Constructorilor

Constructorii sunt un alt aspect fundamental al unei clase. Pentru a crea un obiect dintr-o clasă va trebui să apelați unul dintre constructorii acesteia. Fiecare constructor are un modificator de acces opțional și același nume ca și clasa sa. Pentru limbajele de programare orientate pe obiecte, există în general trei tipuri de constructori:

  • Constructor implicit: nu ia argumente și oferă fiecărui atribut o valoare implicită.
  • Constructor primar: preia unul sau mai multe argumente (în funcție de numărul de variabile din clasă).
  • Copiere constructor: ia ca argument un alt constructor.

C# are un termen umbrelă pentru constructorii impliciti și primari de mai sus - constructorii de instanță. Acest limbaj de programare are și alți doi constructori (privat și static). Acest articol se concentrează pe cei trei constructori tradiționali.

Constructor implicit

// constructor implicit
public Client()
{
 IdNumber = 0;
 Nume = "necunoscut";
 Total = 0;
}

Constructor primar

// constructor primar
publicClient(int IdNumber, șir Nume, șir CustomerType, dubla Total)
{
acest.IdNumber = IdNumber;
acest.Nume = Nume;
acest.Total = Total;
}

Copie constructor

// constructor de copiere
public Client (client anterior)
{
acest.IdNumber = client anterior. Numar de identificare;
acest.Nume = Client anterior. Nume;
acest.Total = Client anterior. Total;
}

Crearea Metodelor

Metodele nu sunt o componentă crucială a clasei, dar sunt utile. O clasă poate avea una sau mai multe metode. O metodă are un modificator de acces, un tip de returnare, un nume și un corp.

// metoda
public șir CustomerDetail()
{
 întoarcere " ID: " + Număr Id + " Nume: " + Nume + " Total: " + Total;
}

Codul de mai sus returnează o reprezentare șir a obiectului client.

Crearea obiectelor

După crearea unei clase complete, echiparea acesteia cu atribute, constructori și o metodă, puteți începe să creați obiecte folosind diferiți constructori. Pentru a crea un obiect fără atribute, puteți utiliza constructorul implicit:

Clientul Ioan = nou Client();

Linia de cod de mai sus creează un client implicit și îl atribuie unei variabile numite Ioan. Cu Ioan, puteți accesa valoarea implicită a fiecărui atribut de client.

Consolă.WriteLine(Ioan.Nume);

Executarea codului de mai sus afișează următoarele în consolă:

Necunoscut

De asemenea, puteți utiliza Ioan variabilă pentru a accesa orice metodă din clasa client.

Consolă.WriteLine(Ioan.Detalii Client());

Executarea liniei de cod de mai sus imprimă următoarea ieșire în consolă:

ID: 0 Nume: necunoscut Total: 0

Pentru a crea un obiect cu atribute, ai folosi constructorul primar:

Client John = client nou (1001, "John Doe", 250.20);
Consolă.WriteLine(Ioan.Detalii Client());

Executarea codului de mai sus tipărește următoarea ieșire în consolă:

ID: 1001 Nume: IoanCăprioarăTotal: 250.2

Pentru a crea o copie a obiectului de mai sus puteți folosi constructorul de copiere:

Clientul Johnny = nou Client (Ioan);
Consolă.WriteLine(Johnny.Detalii Client());

Executarea codului de mai sus tipărește următoarea ieșire în consolă:

ID: 1001 Nume: IoanCăprioarăTotal: 250.2

După cum puteți vedea, constructorul de copiere este o copie a constructorului primar. Constructorul de copiere poate lua și un constructor implicit ca argument:

Clientul Ioan = nou Client();
Clientul Johnny = nou Client (Ioan);
Consolă.WriteLine(Johnny.Detalii Client());

Executarea codului de mai sus tipărește următoarea ieșire în consolă:

ID: 0 Nume: necunoscut Total: 0

Acum puteți crea și utiliza clase C#

Puteți utiliza paradigma orientată pe obiecte în C# pentru a defini clase și a crea obiecte din acestea. Puteți crea metode pentru fiecare clasă care pot opera apoi pe atributele obiectelor lor.

Cu toate acestea, paradigma orientată pe obiecte nu este singura cu care trebuie să fii familiarizat. Primele trei paradigme de programare sunt imperative, orientate pe obiecte și funcționale.