Meniu

Concepte OOPS în C #: Tutorial Concept de programare orientată pe obiecte

  • Principal
  • Alte
  • Concepte OOPS în C #: Tutorial Concept de programare orientată pe obiecte

oops concepts c object oriented programming concept tutorial

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică conceptele OOPS din C #. Puteți afla despre principiile de programare orientate pe obiecte, cum ar fi polimorfismul, încapsularea, moștenirea și abstractizarea:

Programarea orientată pe obiecte este un model de programare care funcționează pe un principiu care se învârte în jurul obiectelor, mai degrabă decât în ​​acțiune sau logică. Permite utilizatorilor să creeze obiecte pe baza cerinței și apoi să creeze metode pentru a opera asupra acestor obiecte.

Lucrul la aceste obiecte pentru a obține rezultatul dorit este scopul programării orientate pe obiecte.

=> Explorați întreaga serie de tutoriale de instruire C # aici

Concepte OOPS în C #

Să revizuim câteva dintre conceptele pe care le-am învățat în tutorialele noastre anterioare !!

Spațiu de nume

Un spațiu de nume din C # este o colecție de clase. Oferă o structură pentru a păstra un nume de clasă separat de un alt nume de clasă declarându-le într-un spațiu de nume diferit. Pentru ca clasele cu același nume să nu intre în conflict.

Clasă

O clasă este un plan al unui tip de date. Este de fapt o colecție de obiecte. Conține obiecte și definiția operației care trebuie efectuată asupra acelui obiect.

Obiecte

Obiectele sunt instanțele clasei.

În tutorialele noastre anterioare, am aflat deja în detaliu despre clasă și obiecte.

Ce veți învăța:

Concepte OOPS în C #

Programarea orientată pe obiecte oferă mai multe avantaje față de celelalte modele de programare, cum ar fi:

  1. Abordarea modulară precisă și clară pentru programe oferă înțelegere și întreținere ușoară.
  2. Clasele și obiectele create în proiect pot fi utilizate în întregul proiect.
  3. Abordarea modulară permite diferite module să existe independent, permițând astfel mai multor dezvoltatori diferiți să lucreze împreună pe diferite module.

În acest tutorial, ne vom concentra mai mult pe alte concepte majore OOPS:

  1. Incapsularea
  2. Polimorfism
  3. Moştenire
  4. Abstracție

Incapsularea

Incapsularea este un concept de programare orientat pe obiecte, care permite programatorilor să împacheteze date și fragmente de cod într-o incintă. Utilizând programul de încapsulare, puteți ascunde membrii unei clase de altă clasă. Este ca și cum ai înconjura un element logic într-un pachet. Permite doar informații relevante disponibile și vizibile în exterior și asta doar pentru anumiți membri.

Incapsularea este implementată utilizând specificatori de acces. Specificatorul de acces este utilizat pentru definirea vizibilității și accesibilității membrului clasei în C #.

C # conține următorii specificați de acces.

aplicații pentru a converti videoclipuri YouTube în mp3
  • Public
  • Privat
  • Protejat
  • Intern

Specificatorii de acces definesc vizibilitatea clasei și valorile acesteia. Vă permite să faceți date vizibile pentru o anumită parte a codului și să le ascundeți de altă parte. Vizibilitatea cea mai frecvent utilizată este publică și privată.

Să le aruncăm o privire.

Public: Cuvântul cheie public permite membrilor săi să fie vizibili de oriunde din interiorul proiectului. Acest specificator de acces are cea mai mică restricție de vizibilitate.

Privat: Membrii privați pot fi accesați doar de către membrii din aceeași clasă. Aceasta are una dintre cele mai restrânse vizibilități.

Protejat: Accesibilitatea protejată permite accesul membrilor din interiorul clasei și de la o altă clasă care moștenește această clasă.

Intern: Intern oferă accesibilitate din cadrul proiectului. O altă accesibilitate internă similară este protejată intern. Acest lucru permite același lucru ca și internul și singura diferență este că o clasă copil poate moșteni această clasă și ajunge la membrii săi chiar și dintr-un alt proiect.

Polimorfism

Polimorfismul este derivat din dicționarul grecesc, înseamnă unul cu multe forme. Poly înseamnă mulți, iar Morph înseamnă forme. Permite clasei din C # să aibă mai multe implementări cu același nume.

Polimorfismul este împărțit în două părți:

  1. Compilare-timp Polimorfism
  2. Polimorfismul timpului de rulare

# 1) Polimorfism de timp static sau de compilare

Polimorfismul în timp de compilare este, de asemenea, cunoscut sub numele de Polimorfism static. Supraîncărcarea metodei este una dintre modalitățile prin care se realizează polimorfismul în timp de compilare. Este cunoscut sub numele de polimorfism în timp de compilare, deoarece decizia de apelare a metodei este luată în momentul compilării.

Se realizează păstrând același nume al metodei, dar trecând seturi diferite de parametri. În supraîncărcarea metodei, sistemul verifică mai întâi parametrul utilizat și, pe baza setului de parametri, decide să apeleze metoda adecvată.

Exemplu:

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }

În exemplul de mai sus, am numit aceeași metodă „print” de două ori folosind parametri diferiți. La început, trecem doi parametri întregi ca parametri, apoi am trecut două șiruri ca parametri. Există două metode de „tipărire” cu același nume.

Când trecem un parametru cu sistemul întregului, acesta va căuta metoda numită „print” care acceptă doi parametri întregi și va executa acest lucru ignorând alte metode cu același nume.

În partea a doua, am trecut parametrul șir. Din nou, sistemul va căuta metoda care acceptă doi parametri șir. Prin urmare, pe baza parametrilor trecuți, prima metodă va adăuga două numere întregi, iar următoarea va concatena două șiruri.

# 2) Polimorfism dinamic sau polimorfism în timpul rulării

Polimorfismul în timpul rulării sau polimorfismul dinamic apare atunci când numele metodei și semnătura metodei au același nume și parametri. Anularea metodei este un exemplu de polimorfism dinamic. Permite utilizatorului să creeze o clasă abstractă cu implementare parțială a interfeței.

Anularea metodei se realizează folosind moștenirea. Pentru a obține o metodă care suprascrie atât clasa de bază, cât și clasa derivată ar trebui să aibă același nume și parametru. În timpul compilării, compilatorul nu este capabil să recunoască metoda de suprascriere, prin urmare, nu aruncă nicio eroare. Decizia de a rula o metodă este luată în timpul rulării.

Exemplu:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Dacă rulăm programul de mai sus, vom obține următoarea ieșire:

Printing from class Execute

Chiar dacă clasa Execute a moștenit toate metodele clasei Program, dar când am numit metoda print care este prezentă în ambele clase, metoda prezentă în clasa copil va suprascrie metoda din clasa părinte.

Polimorfismul dinamic este utilizat pentru implementarea abstractizării. Permite utilizatorului să creeze o clasă abstractă care este utilizată pentru a furniza o implementare pentru o interfață atunci când este moștenită de o clasă derivată. Clasa abstractă poate conține nume / semnături ale metodelor, iar clasa derivată poate avea o definiție mai specializată pentru metodă.

Moştenire

Moștenirea este o parte importantă a conceptului OOPS. În moștenire, definim clasele părinte și copil. Clasa copil poate moșteni toate metodele, obiectele și proprietățile clasei părinte. O clasă de copii poate avea, de asemenea, propriile sale metode și implementare specifică.

Clasa părinte este, de asemenea, cunoscută sub numele de clasă de bază, iar clasa copil care moștenește clasa de bază este, de asemenea, cunoscută sub numele de clasă derivată.

Exemplu:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Aici, avem o clasă numită ca un program care are o singură metodă. Mai avem o altă clasă Execute care moștenește clasa Program. Clasa Execute este clasa derivată, iar programul clasei este cunoscut sub numele de clasă de bază.

Acum, în loc să creăm o instanță obiect pentru programul clasei, am creat o instanță obiect pentru clasa Execute. Folosind această instanță putem accesa metoda de imprimare din clasa de bază.

Deci, ieșirea codului de mai sus va fi:

Printing from class Program

Clasa derivată nu moștenește doar metode, ci și moștenește aproape toți membrii clasei, cum ar fi câmpuri, proprietăți etc., în funcție de vizibilitate. Moștenirea în C # nu permite utilizarea mai multor moșteniri, adică o clasă nu poate moșteni din mai multe clase diferite, cu toate acestea, o clasă poate moșteni dintr-o altă clasă care poate moșteni dintr-o altă clasă.

Abstracție

Abstracția este unul dintre principiile majore ale programării orientate pe obiecte. Abstracția permite programatorului să afișeze lumii doar detaliile necesare în timp ce îi ascunde pe ceilalți. Abstracția se realizează în C # utilizând clasa și interfața Abstract.

O clasă poate fi declarată ca o clasă abstractă utilizând cuvântul cheie „Abstract”. Clasa Abstract în C # este întotdeauna clasa de bază în ierarhie. Ceea ce îi face diferiți de cealaltă clasă este că nu pot fi instanțiați. O clasă abstractă C # trebuie moștenită.

Exemplu:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }

Rezultatul următoarelor este:

Description of the car

Dacă îl comparați cu exemplele noastre anterioare în timpul moștenirii sau polimorfismului dinamic, atunci veți găsi asemănările. Cea mai recunoscută diferență este utilizarea cuvântului cheie abstract înainte de clasa Mașină. În cazul în care doriți să înlocuiți acest lucru sau să furnizați propria dvs. implementare similară cu ceea ce am făcut în polimorfismul dinamic. Apoi, puteți realiza acest lucru prin următoarele.

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

Deci, dacă executați acest cod acum, acesta va da următoarea ieșire:

Description of the car is now Hyundai

Metoda clasei derivate suprascrie metoda clasei de bază. În acest fel, puteți crea o altă clasă derivată, cum ar fi Ferrari, Porsche, BMW etc., cu propriile lor metode de implementare.

Dacă priviți cu atenție, puteți vedea că metoda noastră de descriere din clasa abstractă nu conține nicio implementare.

Atunci, de ce definim metode goale?

Acest lucru se datorează faptului că o clasă Abstract oferă o semnătură a metodelor și face ca obligația pentru subclasele de a crea o implementare pentru toate aceste metode. Acest lucru permite partajarea clasei de bază, dar, în același timp, păstrează și o verificare a implementării metodei clasei derivate.

Interfață

În C #, interfața este planul unei clase. Interfața este similară cu o clasă abstractă și este utilizată pentru a realiza o abstractizare sută la sută. Toate metodele descrise în interfață sunt abstracte în mod implicit. Nu are niciun corp de metodă și nu poate fi instanțiat.

Interfața este utilizată în principal pentru a obține moștenire multiplă și abstractizare completă. Toată semnătura metodei declarată în interfață ar trebui să fie furnizată cu implementare de la clasă sau structura care o implementează.

Exemplu:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }

Ieșirea codului de mai sus va fi:

Description of the car is now Hyundai

Aici, am creat o interfață Mașină. Deoarece interfața nu poate avea nici o definiție a metodei, tocmai am furnizat numele metodei și tipul de returnare în interfață. Am implementat apoi interfața Mașină la o altă clasă Hyundai. În clasa implementată am furnizat definiția metodelor definite în interfață.

Concluzie

În conceptul de programare orientată pe obiecte, fiecare parte a programului este tratată ca un obiect. Clasa este o colecție de tipuri similare de elemente și un obiect este instanța clasei.

Incapsularea în C # permite utilizatorului să stabilească vizibilitatea clasei și a membrilor săi. Polimorfismul permite metodelor să aibă același nume, dar cu parametri diferiți în aceeași clasă sau cu același parametru într-o clasă diferită.

Moștenirea este atunci când o clasă copil, cunoscută și sub numele de clasă derivată, moștenește toate proprietățile, inclusiv metodele, obiectele, câmpurile etc. ale clasei părinte, cunoscută și sub numele de clasă de bază. Abstracția permite programului să afișeze doar semnătura în timp ce ascunde detaliile implementării.

Program consolidat

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

=> Explorați întreaga serie de tutoriale de instruire C # aici

Lectură recomandată

^