Oop, obiecte, clase. Moștenirea și interfețele

Începând să scrie un program, un dezvoltator modern ar trebui să se gândească mai întâi de toate la arhitectura viitorului proiect. În ceea ce privește abordarea orientată pe obiecte a dezvoltării de software, acest lucru înseamnă că un programator trebuie să creeze cod care constă din blocuri logice (clase și obiecte) și să se gândească la interacțiunea acestora. Codul trebuie să poată fi întreținut. Acest lucru înseamnă că programul în cauză poate fi extins sau extins fără probleme în viitor, fără a schimba componentele sale de bază.

În paradigma de dezvoltare orientată pe obiecte există trei instrumente de bază pe care dezvoltatorii le folosesc pentru a scrie un cod bun

• Încapsulare.
• Moștenirea.
• Polimorfism.
• Moștenirea.

Moștenirea

Acesta este un proces de creare a unei noi clase pe baza uneia existente. Abordarea orientată pe obiecte se aplică în primul rând pentru a descrie concepte și fenomene din lumea reală într-un limbaj de programare. Prin urmare, pentru a înțelege OOP trebuie să învățați să descrieți sarcina cu care se confruntă programatorul în limbajul claselor și obiectelor.

Pentru a înțelege ideea de proces de moștenire, putem lua un exemplu din viață. Există o noțiune abstractă de "om". Fiecare ființă umană are caracteristici comune, care pot fi folosite pentru a o descrie. Este vorba de înălțime, greutate, culoarea părului, tonul vocii etc. Ivan Ivanov, elev al clasei 1 "A", este un reprezentant concret al conceptului "uman", adică, folosind limbajul abordării orientate pe obiecte, Ivanov Ivan este un succesor al conceptului "uman". Sau, de exemplu, Barsik, pisica vecinului nostru, este un moștenitor al conceptului "pisică". Se poate face o moștenire mai complexă: Barsik este moștenit de la Maine Coon, care la rândul său este moștenit de la Cat.

Cum este descris acest lucru de către limbajul de programare?

În dezvoltarea software Procesul de moștenire face posibilă crearea unei clase bazate pe alte clase. Clasa părinte se numește clasă de bază, iar ceilalți descendenți se numesc derivate. Moștenirea este atunci când metodele, proprietățile și câmpurile părintelui sunt transmise descendenților. Sintaxa de moștenire clase în limba Programarea în C# ar putea arăta în felul următor. De exemplu:

class Ivan : Person{// class body{

Un exemplu de mecanism de moștenire a claselor:

class Person{public int Age { get; set; }}class Ivan : Person{public void Talk(){/ Ivan vorbește}}class Peter : Person{public void Walk(){/ Peter merge}}class Program{static void Main(string[] args){Ivan ivan = new Ivan();ivan.Age = 29; // denotă vârstaPeter = new Peter();peter.Vârsta = 35ivan.Talk();peter.Walk()();}}

Derivată din clasa de bază Person, sunt create clase derivate, iar proprietatea Age este disponibilă pentru ambele clase.

Constructorul clasei de bază

Atunci când se creează o clasă cu un constructor declarat și o clasă copil, apare o întrebare logică: ce constructori vor fi responsabili pentru crearea obiectelor din aceste clase?

Dacă este specificat numai într-o clasă moștenită, atunci când este creat un obiect, este apelat constructorul implicit (clasa părinte) și apoi succesorul său.

În cazul în care constructorii sunt specificați atât în clasele părinte, cât și în clasele copil, cuvântul cheie base este utilizat pentru a apela constructorul. Atunci când se declară o astfel de structură de moștenire, se utilizează următoarea sintaxă pentru a specifica constructorul:

public Ivan (int age) : base (age){//corp constructor}

Moștenirea metodelor de clasă este cea mai importantă caracteristică a OOP. Atunci când se creează un obiect al unei clase derivate, argumentele constructorului clasei de bază sunt trecute în acesta, după care se apelează constructorul acesteia și apoi se efectuează celelalte apeluri ale constructorului clasei derivate.

Accesarea câmpurilor dintr-o clasă copil

Moștenirea accesului la proprietățile și metodele unei clase de bază de către o clasă derivată devine posibilă dacă toate sunt declarate cu următoarele cuvinte cheie

1. Public.

Oferă acces nerestricționat la membrii clasei: de la Main, de la clasele derivate, de la alte analogi.

2. Protejat.

Member poate fi accesat numai din clasa sursă sau din omologii derivați.

3. Intern.

Restricția unui membru este localizată doar de ansamblul acestui proiect.

4. Interior protejat.

Accesul la un membru este restricționat numai de ansamblul acestui proiect sau de clasele derivate.

Moștenirea accesului la membrii clasei depinde de cuvintele cheie. Dacă nu este specificat ca atare la declararea unui membru, accesibilitatea este setată în mod implicit (private).

Moștenirea multiplă

Interfețele sunt un contract care garantează că un set de metode vor fi implementate într-o clasă descendentă a interfeței. Acestea din urmă nu conțin membri statici, câmpuri, constante sau constructori. Este ilogic și imposibil să se creeze obiecte de interfață.

Aceste structuri sunt create în afara claselor și sunt declarate cu ajutorul cuvântului cheie "interfață":

interfața IMyInterfave{void MyMethod (int someVar);}

O bună regulă de bază atunci când se creează interfețe este de a începe numele construcției cu majusculă, astfel încât acestea să poată fi ușor de distins ulterior. În corpul interfeței, se declară semnăturile membrilor săi.

Pentru a indica faptul că o clasă va implementa o interfață, este necesar să se precizeze numele structurii după declarația clasei, la fel ca în cazul moștenirii normale:

class MyClass : IMyInterface{public void MyMethod (int someVar)}

Interfețe sunt necesare pentru, pentru a implementa moștenirea multiplă. В limbaj de programare C++, dar moștenirea claselor este posibilă; C# folosește interfețe în acest scop. O clasă poate implementa mai multe interfețe, caz în care acestea sunt enumerate după declarația clasei, separate prin virgule:

class MyClass : IMyFirstInterface, IMySecondInterface{//class body}

În mod implicit, toate proprietățile și metodele interfețelor sunt publice, astfel încât care trebuie Definiți unele funcționalități care vor fi implementate ulterior în clasă. Moștenirea în C# implică aproape întotdeauna utilizarea acestui instrument la îndemână.

Puțin mai multe despre moștenirea claselor

Java, C#, C++ - toate limbajele orientate pe obiecte implementează mecanismul de moștenire în felul lor propriu. Dar esența este aceeași peste tot: transmiteți proprietățile părintelui către obiectul copil. Interfețele, clasele abstracte sunt toate instrumente convenabile pentru a implementa acest lucru.