Meniu

Concepte C #: Constructor, Destructor, Clasă statică, Struct & Enum

  • Principal
  • Alte
  • Concepte C #: Constructor, Destructor, Clasă statică, Struct & Enum

c concepts constructor

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică unele dintre conceptele importante din programarea C #, cum ar fi Constructor, Destructori, Clasa statică, Structuri și Enumere:

Într-unul dintre tutorialele noastre anterioare despre obiecte și clase, am aflat ce sunt o clasă și un obiect.

Un obiect este similar cu un obiect din lumea reală și o clasă este o colecție logică de tipuri similare de obiecte. Este unul dintre cele mai fundamentale tipuri prezente în C #. În acest tutorial, ne vom scufunda adânc în celelalte concepte C # conexe.

=> Explorați aici seria de antrenament completă C #

C # Constructor și alte concepte

În acest tutorial, vom învăța despre câteva aspecte importante ale orelor și cum le putem folosi în programele noastre. Vom încerca să creăm programe C # simple pe baza conceptelor pe care le-am învățat în tutorialele noastre anterioare.

Ce veți învăța:

Ce este un constructor în C #?

Constructorul este un tip special de metodă în limbajul de programare C # care este apelat sau invocat automat atunci când este creat un obiect din clasa dată.

Funcția sa principală este de a inițializa datele de membru ale obiectului nou creat. Una dintre cele mai distinctive trăsături ale constructorului este numele său. Are același nume ca și clasa.

Constructorii sunt practic de două tipuri:

  1. Mod implicit
  2. Parametrizat

C # Constructor implicit

După cum sugerează și numele, constructorul implicit este constructorul de bază al unei clase. Nu are niciun argument și este invocat direct în momentul creării obiectului.

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

Ieșirea următorului program va fi:

Constructor a fost invocat

Explicaţie

Am definit un constructor „Program” în cadrul clasei „Program”. Acum, când inițializăm clasa în interiorul metodei principale, constructorul este invocat automat.

Prin urmare, orice fragment de cod pe care l-am păstrat în interiorul constructorului va fi invocat. Aici, am imprimat un mesaj „Constructor a fost invocat” în interiorul acoladelor constructorului, deci atunci când inițializăm clasa, constructorul va fi inițializat în mod implicit și mesajul va fi tipărit ca ieșire.

Constructor parametrizat

După cum sugerează și numele, constructorii parametrizați sunt constructorii cu parametri. Acești constructori sunt folosiți pentru a transmite diferite valori obiectelor.

public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string() args) { Details d = new Details(2, 3); } }

Ieșirea următorului program va fi:

combinați codul de sortare în c ++ cu recursivitate

Suma este: 5

Explicaţie

În exemplul nostru anterior cu constructorul implicit, avem metoda noastră principală în aceeași clasă. În acest exemplu, avem metoda principală într-o clasă diferită.

Avem o clasă numită „Detalii” care conține un constructor parametrizat care acceptă două valori întregi. În interiorul constructorului, imprimăm însumarea numerelor întregi. Avem o altă clasă numită „Program” care conține metoda noastră principală. În cadrul metodei principale, am inițializat clasa „Detalii”.

După cum s-a explicat mai devreme, când se inițializează o clasă, constructorii ei sunt chemați automat. Astfel, în acest caz, metoda noastră de constructor „Detalii” a fost invocată și când am trecut parametrul în timpul inițializării, acesta imprimă ieșirea.

Distructori în C #

Distructorii sunt exact opusul constructorilor. Este o metodă specială a clasei care este invocată atunci când un obiect de clasă iese din sfera de aplicare. Similar cu un constructor, un nume de destructor este, de asemenea, exact același cu cel al numelui clasei, dar cu un prefix de „~” (tilde).

Destructorul nu acceptă niciun parametru și nici nu returnează nicio valoare. Destructor distruge obiectele clasei, prin urmare este utilizat în principal pentru a elibera memoria după executarea programului. Un alt lucru important de remarcat despre destructor este că nu poate fi nici supraîncărcat, nici nu poate fi moștenit.

Exemplu de destructori:

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

Ieșirea următorului program va fi:

Constructor a fost invocat
Destructorul a fost invocat

Explicaţie

Am folosit același exemplu pe care l-am folosit pentru a învăța constructorul. Tocmai am adăugat un destructor în clasa de program (~ Program). Când inițializăm obiectul clasei, se invocă constructorul și se creează obiectul clasei. Aceasta imprimă expresia „Constructor a fost invocat” pe consolă.

Când executarea a fost finalizată și obiectul clasei iese din sfera de aplicare, programul se îndreaptă spre destructor. Se invocă apoi distructorul, care la rândul său distruge obiectul. Aici, am imprimat un mesaj în interiorul destructorului, care se tipărește în consolă după ce distructorul este invocat.

Membrii statici dintr-o clasă

Membrii clasei pot fi declarați statici folosind cuvântul cheie static. Când un obiect este declarat static, indiferent de numărul de obiecte create, va exista o singură copie a obiectului static.

A fi static implică faptul că va exista o singură instanță a membrului care va exista pentru o anumită clasă. Înseamnă că valoarea funcției statice sau a variabilelor din clasă poate fi invocată fără a crea un obiect pentru acestea.

Variabilele statice sunt utilizate pentru declararea constantelor, deoarece valorile lor pot fi obținute direct prin invocarea clasei, mai degrabă decât prin crearea unei instanțe a acesteia.

Exemplu:

public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string() args) { Details.stat(); } }

Ieșirea următorului program va fi:

Metoda statică invocată

Explicaţie

În exemplul de mai sus, am creat o clasă „Detalii” care conține o metodă statică „stat”. Mai avem o altă clasă „Program” care conține metoda principală. În subiectele noastre anterioare, am văzut cum putem inițializa o clasă pentru a accesa metode. Dar, după cum am discutat, membrii statici ai clasei pot fi accesați cu inițializarea obiectului clasei.

Astfel, în metoda principală, tocmai am invocat metoda folosind clasa direct, fără a crea niciun obiect. Ieșirea programului a executat codul scris în interiorul metodei statice. În acest caz, am imprimat un mesaj pe consolă.

Clasa statică în C #

O clasă statică este similară cu o clasă normală în C #. Clasa statică poate avea numai membri statici și nu poate fi instanțiată. O clasă statică este utilizată pentru a vă asigura că clasa nu este instanțiată. O clasă statică este declarată utilizând cuvântul cheie static înainte de clasa cuvântului cheie în timpul declarației.

Exemplu:

public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string() args) { Details.multiply(2,8); } }

Ieșirea următorului program va fi:

Rezultatul multiplicării este: 16

Explicaţie

În exemplul de mai sus, am creat o clasă statică „Detalii” și în interiorul clasei statice am creat o altă metodă statică „multiplicați”. În interiorul metodei, avem câteva fragmente de cod pe care vrem să le executăm. Avem, de asemenea, o altă clasă „Program” cu metoda principală.

În cadrul metodei principale, am invocat metoda de multiplicare prezentă în clasa statică. Dacă vă uitați la metoda noastră principală, veți vedea că nu am inițializat sau creat un obiect pentru clasa statică, în schimb, am invocat clasa din metoda principală.

Astfel, atunci când invocăm direct metoda de multiplicare folosind numele clasei și oferind parametri, aceasta execută codul și tipărește ieșirea.

cum se creează un e-mail de companie fals

Structuri în C #

Entitatea de tip valoare din C # se numește structură. Ajută utilizatorul să stocheze date conexe din mai multe tipuri de date diferite într-o singură variabilă. După cum sa menționat, o structură este o entitate de tip valoare care deține câmpuri, metode, constructori, operatori, evenimente etc. O structură este declarată utilizând cuvântul cheie „struct”.

Caracteristicile structurilor:

  • Poate include constante, metode, proprietăți, index, operatori, constructori etc.
  • Nu poate avea niciun constructor implicit.
  • Poate implementa o interfață, dar nu poate moșteni cu alte structuri sau clase.
  • Structurile trebuie inițializate utilizând un nou cuvânt cheie pentru utilizare.

Diferența dintre struct și clasă

Struct și Class se pot simți într-un fel asemănători, dar au mai multe diferențe.

Diferențele includ:

  • O structură este un tip de valoare în timp ce o clasă este un tip de referință.
  • Noul cuvânt cheie este necesar pentru inițializarea structurilor.
  • Structurile pot avea doar un constructor parametrizat și, pe de altă parte, o clasă poate avea atât constructori impliciți, cât și constructori parametrizați.

Struct: Definiție

O structură poate fi definită utilizând cuvântul cheie struct. O structură poate defini un nou tip de date cu mai mulți membri diferiți pentru program.

O structură poate fi inițializată într-un mod similar cu cel al inițializării unui obiect, adică folosind noul cuvânt cheie. Deoarece o structură este o entitate de tip valoare, este mai rapid de operat decât un obiect de clasă. Oriunde este nevoie să stocăm date, trebuie să folosim o structură. Pe de altă parte, dacă trebuie să transferați date, atunci este recomandabil să utilizați clasa decât o structură.

Exemplu:

public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string() args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }

Ieșirea următorului program va fi:

Volumul cuboidului este: 6000

Explicaţie

În exemplul de mai sus, am definit un struct cuboid în interiorul căruia am stocat tipurile de date pentru lungimea, lățimea și înălțimea cuboidului. Avem un alt program de clasă în care avem metoda noastră principală.

În metoda principală, inițializăm structura „Cuboid” utilizând noul cuvânt cheie. Apoi am folosit obiectul pentru a apela și a atribui valori tipurilor de date stocate în struct. Apoi am efectuat o operație asupra variabilelor din struct și am imprimat rezultatul pe consolă.

Deci, dacă doriți să utilizați orice proprietate, evenimente sau metode, structura trebuie inițializată folosind noul cuvânt cheie, altfel vă va da o eroare de compilare.

Enumerări în C #

Enum este un set de constante întregi și similar cu o structură este, de asemenea, o entitate de tip valoare. Este utilizat în principal pentru a declara o listă de numere întregi utilizând cuvântul cheie „enum” într-un spațiu de nume, clasă sau chiar struct. În enum, oferim un nume fiecărei constante întregi, astfel încât să le putem referi folosind numele lor respective.

Enum poate avea un număr fix de constante. Ajută la îmbunătățirea siguranței și poate fi, de asemenea, traversat.

Caracteristicile Enum

  • Enum îmbunătățește lizibilitatea și menținerea codului prin furnizarea de nume semnificative constantelor.
  • Enum nu poate fi utilizat cu constantele de tip șir.
  • Enum poate include constante precum int, long, short, byte etc.
  • În mod implicit, valoarea constantelor enum începe cu zero

Declararea unei enumere

Sintaxa pentru declararea enum este dată mai jos.

enum { list of integer constants };

Toate constantele enum au valori implicite. Valoarea începe de la 0 și se mișcă în sus unul câte unul.

Exemplu:

public enum Cuboid{ length, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

Ieșirea următorului program va fi:

Lungimea este: 0
Lățimea este: 1
Înălțimea este de: 2

Explicaţie

Am lucrat cu un exemplu similar pe care l-am învățat în timpul struct. În acest exemplu, am creat un enum numit Cuboid. Această enumere conține trei membri, adică lungimea, lățimea și înălțimea.

Avem un alt program de clasă în cadrul căruia avem metoda noastră principală. O distribuție explicită a fost utilizată pentru a converti variabilele de tip enum în tip întreg, apoi le-am stocat valorile în diferite variabile din metoda principală și le-am tipărit în consolă.

În mod implicit, valoarea primei enumere va fi zero, a doua va avea 1 și așa mai departe. Prin urmare, când am tipărit valorile, am primit rezultatul menționat anterior.

Schimbarea valorii Enum

Enum permite, de asemenea, utilizatorilor să schimbe indicele de pornire implicit al membrilor. După ce ați modificat indicele de pornire al variabilei, membrii următori vor avea valorile actualizate în secvența incrementală.

Să atribuim o valoare primului membru al enumului pe care l-am definit în exemplul nostru anterior și să vedem ce se întâmplă:

public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

Ieșirea următorului program va fi:

Lungimea este de: 10
Lățimea este: 11
Înălțimea este de: 12

Explicaţie

Când am atribuit primul membru al enum cu o valoare, atunci toți membrii ulteriori ai enum vor fi atribuiți cu creșterea valorii respective. După cum am definit, prima valoare este 10, valoarea ulterioară devine 11 și următoarea devine 12.

Utilizatorul poate atribui orice valoare conform alegerii sale și toți membrii enum vor fi alocați automat cu creșterea valorilor definite de utilizator.

Proprietăți în C #

Proprietățile din C # sunt, în principiu, membrul denumit al interfeței, claselor și struct. Proprietățile sunt o extensie a variabilelor membre / metoda structurii sau clasei. Acestea sunt folosite pentru a citi, scrie sau modifica valoarea câmpurilor private.

Proprietățile sunt accesate la fel ca câmpurile. Au accesorii care pot fi folosiți pentru a obține, seta și calcula valorile. De asemenea, putem pune logică în timp ce setăm valori în proprietăți. Poate fi folosit și cu clasa privată care restricționează accesul din exterior, dar, în același timp, permite utilizatorului să utilizeze proprietăți pentru obținerea sau setarea valorilor.

Ce sunt accesorii?

Accesorii proprietății constituie declarațiile care pot fi utilizate pentru a citi, scrie sau calcula o proprietate dată. Declarația de proprietate poate conține get, set sau ambele.

Exemplu:

public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string() args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }

Când fragmentul de cod de mai sus este compilat și executat cu succes, se observă următoarea ieșire.

Volumul cubului este: 125

Explicaţie

În exemplul de mai sus, avem o clasă „Cube” în interiorul căreia am declarat o proprietate „Side” de tip întreg. După aceea, am obținut și setat proprietatea unde am returnat și am furnizat valoarea către partea variabilă.

cel mai bun pop-up blocker pentru crom

Mai avem o altă clasă „Program” cu metoda principală în interiorul căreia am inițializat clasa Cube și am furnizat valoarea proprietății Side și apoi am imprimat rezultatul calculat în consolă.

Concluzie

În acest tutorial, am aflat despre funcțiile membrilor clasei. O funcție membru poate opera pe orice obiect al clasei unde este prezentă. Am aflat și despre constructori și destructori.

Constructorii sunt inițializați automat în momentul creării obiectului clasei, în timp ce distructorii distrug clasa și sunt folosiți în principal pentru a elimina alocarea memoriei după finalizarea execuției. Constructorii pot fi de două tipuri, adică implicit și parametrizat.

Distructorul nu acceptă niciun parametru și nici nu returnează nicio valoare. Atât Constructor cât și Destructors au nume care sunt exact aceleași cu numele clasei. De asemenea, am aflat despre variabilele statice și clasa statică și despre cum pot fi accesate fără a utiliza instanțe de clasă. Am aflat că o clasă statică poate avea numai membri statici.

Am discutat și despre Structuri sau structuri. Structurile sunt entități de tip valoare și trebuie inițializate pentru acces.

Enum și proprietățile C # au fost, de asemenea, discutate. Enum este un set de constante întregi numite. Similar structurii, este și o entitate de tip valoare. Enum va avea membrii săi și fiecare membru va avea propria valoare implicită.

La final, am discutat despre proprietăți, care sunt o extensie a variabilelor membre / metodei structului sau clasei. Sunt folosite pentru a obține, seta sau modifica valoarea câmpurilor private.

=> Vedeți seria noastră completă de antrenament C # aici

Lectură recomandată

^