Oop este. Caracteristicile programării orientate pe obiecte

2. Definiți conceptul de „clasă”.
3. Ce este un câmp/atribut de clasă?
4. Cum se organizează corect accesul la câmpurile de clasă?
5. Definiți conceptul de „constructor”.
6. Care este diferența dintre constructorii impliciti, de copiere și de parametri?
7. Ce modificări ale nivelului de acces cunoașteți, spuneți-ne despre fiecare dintre ele.
8. Spuneți-ne despre caracteristicile unei clase cu un singur constructor privat.
9. Ce înseamnă cuvintele cheie „acest”, „super”, unde și cum pot fi folosite?
10. Definiți conceptul de „metodă”.
11. Ce este o semnătură de metodă?
12. Ce metode se numesc supraîncărcate?
13. Metodele non-statice le pot supraîncărca pe cele statice?
14. Spuneți-ne despre modificarea metodei.
15. Poate o metodă să accepte un număr diferit de parametri (argumente de lungime variabilă)?
16. Este posibil să restrângeți nivelul de acces/tipul de returnare atunci când treceți peste o metodă?
17. Cum se accesează metodele suprascrise ale unei clase părinte?
18. Ce transformări sunt numite în jos și în sus?
19. Care este diferența dintre suprasolicitare și supraîncărcare?
20. Unde pot inițializa câmpurile statice/non-statice?

21. De ce este nevoie de instanța operatorului?
22. De ce sunt necesare blocurile de inițializare și ce sunt acestea?
23. Care este ordinea apelării constructorilor și a blocurilor de inițializare a două clase: un descendent și strămoșul său?
24. Unde și pentru ce se folosește modificatorul abstract?
25. Este posibil să declarați o metodă abstractă și statică în același timp?
26. Ce înseamnă cuvântul cheie static?
27. La care constructe Java se aplică modificatorul static?
28. Ce se întâmplă dacă apare o excepție într-un bloc static de cod?
29. Este posibil să supraîncărcați o metodă statică?
30. Ce este o clasă statică, care sunt caracteristicile utilizării ei?
31. Care sunt caracteristicile inițializării variabilelor statice finale?
32. Cum afectează modificatorul static o clasă/metodă/câmp?
33. Ce înseamnă cuvântul cheie final?
34. Definiți conceptul de „interfață”.
35. Ce modificatori au câmpurile și metodele de interfață în mod implicit?
36. De ce nu poți declara o metodă de interfață cu modificatorul final sau static?
37. Ce tipuri de clase există în java (imbricate... etc.)
38. Care sunt caracteristicile creării claselor imbricate: simple și statice.
39. Ce știi despre clasele imbricate, de ce sunt folosite? Clasificare, cazuri de utilizare, încălcare a încapsulării.
40. Care este diferența dintre clasele imbricate și cele interioare?
41. Ce clase se numesc anonime?
42. Cum se accesează un câmp al unei clase exterioare dintr-o clasă imbricată?

43. Cum poți accesa o variabilă locală a unei metode dintr-o clasă anonimă declarată în corpul acestei metode? Există restricții pentru o astfel de variabilă?
44. Cum este legată orice clasă de utilizator cu clasa Object?
45. Explicați fiecare dintre metodele clasei Object.
46. ​​​​Ce este metoda equals(). Cum este diferit de operațiunea ==.
47. Dacă doriți să înlocuiți equals(), ce condiții trebuie îndeplinite pentru metoda suprascrisă?
48. Dacă equals() este suprascris, există alte metode care ar trebui înlocuite?
49. Ce este special la metodele hashCode și equals? Cum sunt implementate metodele hashCode și equals în clasa Object? Ce reguli și convenții există pentru implementarea acestor metode? Când sunt folosite?
50. Ce metodă returnează o reprezentare în șir a unui obiect?
51. Ce se întâmplă dacă suprascrieți equals fără a suprascrie hashCode? Ce probleme ar putea apărea?
52. Există recomandări cu privire la ce câmpuri ar trebui folosite la calcularea codului hash?
53. Credeți că vor exista probleme dacă obiectul care este folosit ca cheie într-un hashMap schimbă câmpul care este implicat în determinarea hashCode?
54. Cum diferă o clasă abstractă de o interfață În ce cazuri vei folosi pe care?
55. Este posibil să accesați variabile de clasă privată și, dacă da, cum?
56. Ce sunt volatile și tranzitorii? Pentru ce și în ce cazuri ar putea fi folosit implicit?
57. Extinderea modificatorilor în timpul moștenirii, suprascrierii și ascunderii metodelor. Dacă o clasă părinte are o metodă declarată privată, poate descendentul să-și extindă vizibilitatea? Dacă este protejat? Ce zici de îngustarea vizibilității?
58. Are sens să declari o metodă privată finală?
59. Care sunt caracteristicile inițializării variabilelor finale?
60. Ce se întâmplă dacă singurul constructor al unei clase este declarat final?
61. Ce este finalizarea? De ce este nevoie? Ce ne puteți spune despre colectorul de gunoi și algoritmii săi?
62. De ce este declarată protejată metoda clonării? Ce este necesar pentru a implementa clonarea?

Răspunsuri. Partea 1

1. Numiți principiile POO și spuneți-ne despre fiecare.

Programarea orientată pe obiecte (OOP) este o metodologie de programare bazată pe reprezentarea unui program ca o colecție de obiecte, fiecare dintre acestea fiind o instanță a unei clase specifice, iar clasele formează o ierarhie de moștenire.

Principii de bază ale POO: abstracție, încapsulare, moștenire, polimorfism.

Abstracția- înseamnă evidențierea informațiilor semnificative și excluderea din considerare a informațiilor nesemnificative. Din punct de vedere al programării, aceasta este împărțirea corectă a unui program în obiecte. Abstracția vă permite să selectați caracteristicile principale și să le omiteți pe cele secundare.

Exemplu: descrierea posturilor din companie. Aici titlul postului este o informație semnificativă, iar descrierea responsabilităților fiecărei poziții este o informație secundară. De exemplu, principala caracteristică pentru „director” va fi că această funcție gestionează ceva și ceea ce anume (director de resurse umane, director financiar, director executiv) este o informație secundară.

Încapsulare- o proprietate de sistem care vă permite să combinați datele și metodele care lucrează cu ele într-o clasă. Pentru Java, ar fi corect să spunem că încapsularea „ascunde implementarea”. Un exemplu din viață este o telecomandă a televizorului. Apăsăm butonul „mărește volumul” și crește, dar în acest moment apar zeci de procese care ne sunt ascunse. Pentru Java: puteți crea o clasă cu 10 metode, de exemplu, cele care calculează aria unei figuri complexe, dar fac private 9 dintre ele. A 10-a metodă va fi numită „calculateArea()” și va fi declarată publică, iar în ea vor fi apelate metodele necesare ascunse utilizatorului. Acesta este ceea ce va suna utilizatorul.

Moştenire- o proprietate de sistem care vă permite să descrieți o nouă clasă bazată pe una existentă cu funcționalități împrumutate parțial sau complet. Clasa din care este derivată moștenirea se numește bază, părinte sau superclasă. O nouă clasă este un descendent, moștenitor, copil sau clasă derivată.

Polimorfismul— capacitatea sistemului de a utiliza obiecte cu aceeași interfață fără informații despre tipul și structura internă a obiectului. Exemplu (ușor modificat) din Thinking in Java:

interfață publică Shape ( void draw(); void erase(); ) public class Circle implementează Shape ( public void draw() ( System.out.println("Circle.draw()"); ) ) public class Triangle implementează Shape ( public void draw() ( System.out.println("Triangle.draw()"); ) ) public class TestPol ( public static void main(String args) ( Shape shape1 = new Circle (); Shape shape2 = new Triangle ( ); testPoly(shape1); testPoly(shape2) public static void testPoly(Shape shape) ( shape.draw(); ) //Circle.draw() //Triangle.draw()

interfață publică Forma ( void draw(); void erase(); extragere public nul() ( Sistem. afară . println ("Circle.draw()"); unelte triunghiulare de clasă publică Forma ( extragere public nul() ( Sistem. afară . println("Triunghi.desen()"); clasa publica TestPol( Shape shape1 = new Circle(); Shape shape2 = triunghi nou(); testPoly(forma1); testPoly(forma2); test public de gol staticPoly (Formă de formă) ( formă. a desena(); //Ieșire în consolă: //Circle.draw() //Triangle.draw()

Există o interfață comună „Shape” și două implementări ale acesteia „Triunghi” și „Cerc”. Fiecare are o metodă de „tragere”. Datorită polimorfismului, nu trebuie să scriem o metodă separată pentru fiecare dintre numeroasele forme pentru a numi metoda „desenării”. Apelarea unei metode polimorfe permite unui tip să-și exprime diferența față de un alt tip similar, chiar dacă provin din același tip de bază. Această diferență este exprimată prin acțiunile diferite ale metodelor numite prin clasa de bază (sau interfață).
Iată un exemplu de polimorfism (numit și legare dinamică, sau legare întârziată, sau legare în timp de execuție), care demonstrează cum va fi executată metoda care aparține obiectului trecut în timpul execuției programului.

Dacă nu ar exista polimorfism și legare tardivă, atunci același program ar arăta cam așa:

public static void testPolyCircle(Circle circle) ( circle.draw(); ) public static void testPolyTriangle(triunghi triunghi) ( triangle.draw(); )

public static void testPolyCircle(cercul cerc) ( cerc . a desena(); public static void testPolyTriangle(triunghi triunghi) ( triunghi. a desena();

Acestea. pentru fiecare clasă (formă) am scrie o metodă separată. Sunt două, dar dacă există sute de cifre (clase)?

2. Definiți conceptul de „clasă”.

O clasă este un descriptor al proprietăților comune ale unui grup de obiecte. Aceste proprietăți pot fi atât caracteristici ale obiectelor (dimensiune, greutate, culoare etc.), cât și comportamente, roluri etc.

3. Ce este un câmp/atribut de clasă?

Un câmp de clasă (atribut) este o caracteristică a unui obiect. De exemplu, pentru o figură, acesta ar putea fi numele, zona, perimetrul.

clasă publică Circle implementează Shape (nume String privat; zonă dublă privată; perimetru String privat; )

Clasa publică Circle implementează Forma ( nume șir privat; zona dubla privata ; perimetrul String privat ;

4. Cum se organizează corect accesul la câmpurile de clasă?

Modificatorul de acces este privat. Acces prin metode get\set.

5. Definiți conceptul de „constructor”.

Un constructor este o metodă specială care este apelată atunci când este creat un nou obiect. Constructorul inițializează obiectul direct în momentul creării. Numele constructorului este același cu numele clasei, inclusiv majuscule, iar sintaxa constructorului este similară cu o metodă fără valoare returnată.

clasă publică Circle implementează Shape ( public Circle() ( ) )

Clasa publică Circle implementează Forma ( Cercul public()(

6. Care este diferența dintre constructorii impliciti, de copiere și de parametri?

Constructorul implicit nu acceptă niciun parametru. Constructorul de copiere ia ca parametru un obiect de clasă. Un constructor parametrizat ia ca parametri de intrare (de obicei necesari pentru a inițializa câmpurile clasei).

//constructor implicit public Circle() ( ) //copiere constructor public Circle(Circle circle) ( this(circle.getName(), circle.getArea(), circle.getPerimeter()); //constructorul cu parametrii va fi apelat mai jos) //constructor cu parametri public Circle(Nume șir, zonă dublă, perimetru șir) ( this.name = name; this.area = area; this.perimeter = perimetru; )

// constructor implicit Cercul public()( //copiere constructor Cercul public (cercul cercului) ( this(cercle. getName(), circle. getArea(), circle. getPerimeter()); //va fi apelat constructorul cu parametrii de mai jos //constructor cu parametri Cerc public (nume șir, zonă dublă, perimetru șir) ( acest. nume = nume ; acest. area = area ; acest. perimetru = perimetru ;

Vă rugăm să rețineți că subiectul copierii (clone()) este destul de profund, cu posibilitatea să apară multe probleme ascunse. Puteți citi puțin aici http://habrahabr.ru/post/246993/.

7. Ce modificări ale nivelului de acces cunoașteți, spuneți-ne despre fiecare dintre ele.

• privat (închis) - accesul la un membru al clasei nu este acordat nimănui, cu excepția metodelor din această clasă. Nici alte clase din același pachet nu pot accesa membrii privați.
• default, package, friendly, default access atunci când nu este prezent niciun modificator - un membru al clasei este considerat public în propriul pachet, dar nu este accesibil codului aflat în afara acestui pachet, de exemplu. dacă package2.Class2 extinde package1.MainClass , atunci în metodele Class2 fără identificator din MainClass sunt vizibile nu voi.
• protected (protected) - acces in cadrul pachetului si claselor sale descendente. Accesul într-o clasă dintr-un alt pachet va fi pentru metodele publice și protejate ale clasei principale. Acestea. dacă package2.Class2 extinde package1.MainClass , atunci în interiorul package2.Class2 metodele cu identificatorul protejat din MainClass vor fi vizibile.
• public (deschis) - acces pentru toată lumea din orice alt cod de proiect

Modificatorii din listă sunt aranjați în ordinea creșterii vizibilității în program.

8. Spuneți-ne despre caracteristicile unei clase cu un singur constructor privat.

Este imposibil să creezi un obiect al unei clase care are un singur constructor privat în afara clasei. Prin urmare, nu puteți moșteni dintr-o astfel de clasă. Când încercați să moșteniți, se va afișa o eroare: Nu există un constructor implicit disponibil în ClassName. Și când încercați să creați un obiect din această clasă: ClassName() are acces privat în ClassName

9. Ce înseamnă cuvintele cheie „acest”, „super”, unde și cum pot fi folosite?

super este folosit pentru a se referi la clasa de bază, iar acesta este folosit pentru a se referi la cea curentă. Exemplu:

public class Animal ( public void eat() ( System.out.println("animal eat"); ) ) public class Dog extinde Animal ( public void eat() ( System.out.println("Câinele mănâncă"); ) public void thisEat() ( System.out.println("Call Dog.eat()"); this.eat(); ) public void superEat() ( System.out.println("Call Animal.eat()"); super.eat(); ) public class Test ( public static void main(String args) ( Dog dog = new Dog(); dog.eat(); dog.thisEat(); dog.superEat(); ) ) Dog mănâncă Sună Câine.mâncă() Câine mănâncă Sună Animal.mâncă() animal mănâncă

Animal clasa publica ( public void eat() ( Sistem. afară . println("animalul mananca"); clasă publică Câine se extinde Animal ( public void eat() ( Sistem. afară . println("Cinele mananca"); public void thisEat() ( Sistem. afară . println ("Call Dog.eat()" ); acest. mânca(); public void superEat() ( Sistem. afară . println ("Apelați Animal.eat()"); super. mânca(); test la clasa publica ( public static void main (Argumente șir) ( Câine câine = câine nou (); câine. mânca(); câine. thisEat(); câine. superEat(); Câinele mănâncă Sună câine. mânca() Câinele mănâncă Sună Animal. mânca() animalul mănâncă

Dacă scrieți super(), atunci constructorul clasei de bază va fi apelat, iar dacă this(), atunci constructorul clasei curente. Acesta poate fi folosit, de exemplu, atunci când se apelează un constructor cu parametri:

public Dog() ( System.out.println("Apelați constructorul gol"); ) public Dog(Nume șir) ( System.out.println("Apelați constructorul cu Nume"); this.name = name; ) public Dog( Nume șir, greutate dublă) ( this(name); this.weight = weight; System.out.println("Call constructor with Name and Weight"); ) ) .. public static void main(String args) ( Dog dog1 = new Dog("nume", 25.0 ) //Ieșire constructor de apel cu nume constructor de apel cu nume și greutate

câine public() ( Sistem. afară . println("Apelați constructorul gol"); Câine public (nume șir) ( Sistem. afară . println ("Apel constructor cu nume"); acest. nume = nume ; Câine public (nume șir, greutate dublă) ( acest nume); acest. greutate = greutate ; Sistem. afară . println( „Apel constructor cu nume și greutate”) ; public static void main (Argumente șir) ( Dog dog1 = new Dog ("nume", 25.0); //Concluzie Apelați constructorul cu Nume Apelați constructorul cu nume și greutate

10. Definiți conceptul de „metodă”.

O metodă este o secvență de comenzi care sunt numite printr-un nume specific. Putem spune că aceasta este o funcție și o procedură (în cazul unei metode void).

11. Ce este o semnătură de metodă?

Semnătura unei metode în Java este numele metodei plus parametrii (și ordinea parametrilor contează).
Semnătura unei metode nu include valoarea returnată, excepțiile pe care le aruncă sau modificatorii.

Cuvinte cheie public, protejat, privat, abstract, static, final, sincronizat, nativ, strictfp, incl. adnotările pentru o metodă sunt modificatori și nu fac parte din semnătură.

http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.2

12. Ce metode se numesc supraîncărcate?

Java vă permite să creați mai multe metode cu aceleași nume, dar semnături diferite. Crearea unei metode cu același nume, dar cu un set diferit de parametri se numește supraîncărcare. Java determină ce metodă supraîncărcată ar trebui să fie executată atunci când este apelată pe baza parametrilor actuali.

metoda public void() ( ) metoda public void(int a) ( ) metoda public void(String str) ( )

metoda public nud () ( ) metoda public nud (int a) ( )

a folosit în esență paradigma de programare prescriptivă - scopul a fost de a crea cod care să acționeze în mod corespunzător asupra datelor. Această abordare este bună pentru rezolvarea problemelor mici, dar creează multe probleme insolubile atunci când încearcă să creeze sisteme software mari.

Una dintre alternative programare directivă este programare orientată pe obiecte, care într-adevăr ajută să faceți față complexității în creștere neliniară a programelor pe măsură ce volumul lor crește. Totuși, nu trebuie să concluzionăm că utilizarea paradigmei de programare orientată pe obiecte garantează o soluție de succes la toate problemele.

Pentru a deveni un profesionist în programare, ai nevoie de talent, creativitate, inteligență, cunoștințe, logică, capacitatea de a construi și folosi abstracții și, cel mai important, experiență.

În această secțiune, vom continua introducerea în conceptele de bază ale programarii orientate pe obiecte, pe care le-am început în primul capitol al cărții. În primul rând, vor fi discutate conceptele OOP comune diferitelor limbaje de programare, iar apoi implementarea lor în limbajul Java.

Trebuie să fiți conștienți de faptul că cursul de programare orientată pe obiecte este predat studenților de licență pe parcursul unui semestru întreg și, prin urmare, materialul prezentat mai jos reprezintă doar o introducere de bază în lumea OOP. O tratare mult mai completă a multor probleme legate de proiectarea orientată pe obiecte, inginerie și programare este conținută în carte, iar în al treilea capitol al cărții puteți găsi o descriere foarte clară a tuturor aspectelor orientate pe obiecte ale cărții. limbajul Java.

Concepte de bază OOP

Programare orientată pe obiecte sau OOP (programare orientată pe obiecte) - metodologia de programare bazat pe reprezentarea unui program ca o colecție de obiecte, fiecare dintre acestea fiind o implementare de un anumit tip, folosind un mecanism redirecționarea mesajelor si cursuri organizate in ierarhia moștenirii.

Elementul central al POO este abstractizarea. Datele sunt convertite în obiecte folosind abstractizarea, iar secvența de procesare a acestor date se transformă într-un set de mesaje transmise între aceste obiecte. Fiecare dintre obiecte are propriul său comportament unic. Obiectele pot fi tratate ca entități concrete care răspund la mesaje care le comandă să efectueze o anumită acțiune.

OOP se caracterizează prin următoarele principii (conform lui Alan Kay):

• totul este un obiect;
• calculele sunt efectuate prin interacțiune (schimb de date) între obiecte, în care un obiect necesită alt obiect pentru a efectua o acțiune; obiectele interacționează prin trimiterea și primirea de mesaje; un mesaj este o solicitare de a efectua o acțiune, completată de un set de argumente care pot fi necesare la efectuarea acțiunii;
• fiecare obiect are un independent memorie, care constă din alte obiecte;
• fiecare obiect este un reprezentant al unei clase care exprimă proprietățile generale ale obiectelor de un anumit tip;
• stabilit în clasă funcţionalitate(comportamentul obiectului); astfel, toate obiectele care sunt instanțe ale aceleiași clase pot efectua aceleași acțiuni;
• clasele sunt organizate într-o singură structură arborescentă cu o rădăcină comună, numită ierarhia moștenirii; memoria și comportamentul asociate cu instanțe ale unei anumite clase sunt automat disponibile oricărei clase de mai jos în arborele ierarhic.

Definiție 10.1. Abstracția- o metodă de rezolvare a unei probleme în care obiectele de diferite feluri sunt unite printr-un concept comun (concept), iar apoi entitățile grupate sunt considerate elemente ale unei singure categorii.

Abstracția vă permite să separați sensul logic al unui fragment de program de problema implementării acestuia, împărțind descriere externă(interfață) a unui obiect și a acestuia organizare internă(implementare).

Definiție 10.2. Încapsulare- o tehnică în care informațiile nesemnificative din punctul de vedere al interfeței obiectului sunt ascunse în interiorul acesteia.

Definiție 10.3. Moştenire- o proprietate a obiectelor prin care instanțe ale unei clase obțin acces la datele și metodele claselor strămoși fără a le redefini.

Moștenirea permite diferitelor tipuri de date să partajeze același cod, rezultând un cod mai mic și o funcționalitate mai mare.

Definiție 10.4.

Caracteristici distinctive ale OOP

1) Abordarea OO se concentrează pe date ca elementele cele mai stabile ale unui sistem de calcul

2) Abordarea OO vă permite să dezvoltați cod de program care vizează utilizarea repetată

3) Abordarea OO oferă o scalabilitate mai bună în proiectele software, de ex. crearea de programe de diferite grade de complexitate, motiv pentru care majoritatea tehnologiilor moderne de design implică utilizarea OOP.

În teoria programării, abordarea OO este definită ca o tehnologie pentru crearea de software complex, cat. Bazat pe reprezentarea unui program ca o colecție de obiecte program. Principalul avantaj al OOP este reducerea numărului de apeluri intermodule și reducerea cantității de informații transferate între module în comparație cu programarea modulară. Acest lucru se realizează prin localizarea și integrarea mai completă a datelor cu rutinele de procesare, ceea ce permite dezvoltarea aproape independentă a părților (obiectelor) individuale ale programului.

În plus, abordarea obiectului oferă noi instrumente de dezvoltare tehnologică, precum moștenirea, polimorfismul, compoziția, umplerea, care vă permit să construiți obiecte mai complexe din altele mai simple. Rezultatul este o creștere semnificativă a reutilizarii codului, capacitatea de a crea biblioteci de obiecte pentru diverse aplicații, iar dezvoltatorilor li se oferă oportunități suplimentare de a crea sisteme de complexitate crescută.

OOP se bazează pe următoarele: principii:

1) abstractizare;

2) restricționarea accesului;

3) modularitatea;

4) ierarhie;

5) tastare;

6) paralelism;

7) stabilitate.

Să clarificăm care este fiecare principiu.

Abstracția- procesul de identificare a abstracțiilor în domeniul unei sarcini. Abstracția- acesta este un set de caracteristici esențiale ale unui anumit obiect care îl deosebesc de toate celelalte tipuri de obiecte și, astfel, definesc în mod clar caracteristicile acestui obiect din punctul de vedere al analizei și analizei ulterioare. În conformitate cu definiția, abstracția folosită a unui obiect real depinde în mod semnificativ de problema rezolvată: într-un caz ne va interesa forma obiectului, în altul greutatea, în al treilea - materialele din care este. a făcut, în a patra - legea mișcării obiectului etc. Nivelul modern de abstractizare presupune combinarea tuturor proprietăților de abstractizare (atât cele referitoare la starea obiectului analizat, cât și cele care determină comportamentul acestuia) într-o singură unitate de program, o anumită tip abstract(Clasă).

Limitarea accesului(Încapsularea este principiul conform căruia orice clasă ar trebui tratată ca o cutie neagră - utilizatorul clasei ar trebui să vadă și să folosească doar partea de interfață a clasei (adică, lista proprietăților și metodelor declarate ale clasei) și nu aprofundează în implementarea sa internă. Prin urmare, datele sunt de obicei încapsulate într-o clasă astfel încât accesul la ele prin citire sau scriere să se efectueze nu direct, ci folosind metode. Principiul încapsulării (teoretic) ne permite să minimizăm numărul a conexiunilor dintre clase și, în consecință, simplifica implementarea și modificarea independentă a claselor.) Aceasta este ascunderea elementelor de implementare individuale care nu afectează caracteristicile esențiale ale acesteia în ansamblu.

Necesitatea de a restricționa accesul necesită o distincție între două părți în descrierea abstractizării:

A) interfata- un set de elemente accesibile extern de implementare a abstractizării (principalele caracteristici ale stării și comportamentului);

b) implementare- un set de elemente de implementare a abstractizării care sunt inaccesibile din exterior (organizarea internă a abstracției și mecanismele de implementare a comportamentului acesteia).

Restricționarea accesului în POO permite dezvoltatorului:

1) realizează construcția sistemului pas cu pas, fără a fi distras de caracteristicile de implementare ale abstracțiilor utilizate;

2) este ușor să modificați implementarea obiectelor individuale, care într-un sistem bine organizat nu va necesita schimbarea altor obiecte.

Combinația de a combina toate proprietățile unui obiect (componentele stării și comportamentului său) într-o singură abstracție și limitarea accesului la implementarea acestor proprietăți se numește încapsulare .

Modularitate- acesta este principiul dezvoltării unui sistem software, care presupune implementarea acestuia sub formă de părți separate (module). La descompunerea unui sistem în module, este de dorit să se combine părți legate logic, asigurând, dacă este posibil, o reducere a numărului de conexiuni externe între module. Principiul este moștenit din programarea modulară, urmând să se simplifice proiectarea și depanarea programului.

Ierarhie este un sistem ordonat sau ordonat de abstracții. Principiul ierarhiei presupune utilizarea ierarhiilor în dezvoltarea sistemelor software.

OOP utilizează două tipuri de ierarhie.

1. Ierarhie „întreg/parte”- arată că unele abstractizări sunt incluse în abstractizarea în cauză ca părți ale acesteia, de exemplu, o lampă este formată dintr-o bază, un filament și un bec. Această versiune a ierarhiei este utilizată în procesul de partiționare a sistemului în diferite etape de proiectare (la nivel logic - la descompunerea domeniului subiectului în obiecte, la nivel fizic - la descompunerea sistemului în module și la separarea proceselor individuale în un sistem multiproces).

2. Ierarhie „general/privat”- arată că o anumită abstracție este un caz special al unei alte abstracțiuni, de exemplu, „o masă este un anumit tip de masă” și „mesele sunt un anumit tip de mobilier”. Se folosește la dezvoltarea structurilor de clasă, atunci când clasele complexe sunt construite pe baza celor mai simple prin adăugarea de noi caracteristici și, eventual, clarificarea celor existente.

Unul dintre cele mai importante mecanisme ale POO este moștenirea proprietăților în ierarhia public/privat. Moştenire- aceasta este o relație între abstracții atunci când una dintre ele folosește o parte structurală sau funcțională a altei sau mai multe alte abstracțiuni (moștenirea simplă și respectiv multiplă).

Tastare- aceasta este o restricție impusă proprietăților obiectelor și împiedică interschimbabilitatea abstracțiilor de diferite tipuri (sau reduce foarte mult posibilitatea unei astfel de înlocuiri). În limbajele puternic tipizate, pentru fiecare obiect program (variabilă, subrutină, parametru etc.), este declarat un tip care definește un set de operații asupra obiectului program corespunzător. Limbajele de programare bazate pe Pascal discutate mai jos folosesc tastare strictă, iar cele bazate pe C folosesc un grad mediu de tastare.

Utilizarea principiului de tastare asigură:

1) detectarea precoce a erorilor asociate cu operațiuni nevalide asupra obiectelor program (erorile sunt detectate în etapa de compilare a programului la verificarea admisibilității efectuării unei operațiuni date pe un obiect program);

2) simplificarea documentaţiei;

3) capacitatea de a genera cod mai eficient.

Un tip poate fi asociat cu un obiect software în mod static (tipul obiectului este determinat în timpul compilării - legarea timpurie) și dinamic (tipul obiectului este determinat numai în timpul execuției programului - legarea tardivă). Implementarea legăturii tardive într-un limbaj de programare vă permite să creați variabile - pointeri către obiecte aparținând unor clase diferite ( obiecte polimorfe), care extinde semnificativ capacitățile limbii.

Paralelism- proprietatea mai multor abstracții de a fi într-o stare activă în același timp, i.e. efectua unele operatii.

Există o serie de sarcini, a căror rezolvare necesită executarea simultană a anumitor secvențe de acțiuni. Astfel de sarcini, de exemplu, includ sarcini de control automat al mai multor procese.

Paralelismul real se realizează numai la implementarea sarcinilor de acest tip pe sisteme multiprocesor, când este posibil să se execute fiecare proces pe un procesor separat. Sistemele cu un singur procesor simulează paralelismul prin împărțirea timpului procesorului între sarcinile de gestionare a diferitelor procese. În funcție de tipul de sistem de operare utilizat (un singur program sau multi-program), partajarea timpului poate fi efectuată fie de sistemul în curs de dezvoltare (ca în MS DOS), fie de sistemul de operare utilizat (ca în sistemele Windows).

Durabilitate- proprietatea unei abstracții de a exista în timp indiferent de procesul care a generat un obiect software dat, și/sau în spațiu, deplasându-se din spațiul de adrese în care a fost creat.

Sunt:

1) temporar obiecte care stochează rezultate intermediare ale unor acțiuni, de exemplu, calcule;

2) local obiecte care există în interiorul subrutinelor, a căror durată de viață este calculată de la apelul subrutinei până la finalizarea acestuia;

3) global obiecte care există în timp ce programul este încărcat în memorie;

4) salvat obiecte ale căror date sunt stocate în fișiere de memorie externă între sesiunile de program.

Toate principiile de mai sus sunt implementate într-o măsură sau alta în diferite versiuni ale limbajelor orientate pe obiecte.

De ce este preferată programarea orientată pe obiecte în majoritatea proiectelor? OOP oferă o modalitate eficientă de a face față complexității acestora. În loc să vadă un program ca o secvență de instrucțiuni executabile, acesta îl reprezintă ca un grup de obiecte cu anumite proprietăți și efectuează anumite acțiuni asupra acestora. Acest lucru are ca rezultat aplicații mai curate, mai fiabile și mai ușor de întreținut.

Principiile de bază au apărut deoarece au fost descoperite limitări în abordările preexistente. Printre acestea se numără accesul nelimitat la date și un număr mare de conexiuni care impun restricții la efectuarea modificărilor. Conștientizarea și motivele lor sunt importante pentru a înțelege ce este OOP în programare și care sunt beneficiile acesteia.

Limbi procedurale

C, Pascal, FORTRAN și limbile similare sunt procedurale. Adică, fiecare dintre operatorii lor ordonă computerului să facă ceva: să primească date, să adauge numere, să împartă la șase, să afișeze rezultatul. O aplicație într-un limbaj procedural este o listă de instrucțiuni. Dacă este mic, nu este necesar un alt principiu de organizare (numit adesea paradigmă). Programatorul creează o listă de instrucțiuni și computerul le execută.

Împărțirea în funcții

Pe măsură ce aplicațiile devin mai mari, lista devine greoaie. Puțini oameni pot înțelege mai mult de câteva sute de instrucțiuni până când sunt grupate. Din acest motiv, funcția a devenit o modalitate de a face aplicațiile mai ușor de înțeles pentru creatorii lor. În unele limbi, același concept poate fi numit subrutină sau procedură.

Aplicația este împărțită în funcții, fiecare având un scop și o interfață clar definite.

Ideea de împărțire a procedurilor poate fi extinsă prin gruparea lor într-un obiect mai mare numit modul, dar principiul este similar: gruparea componentelor care execută liste de instrucțiuni.

Împărțirea în funcții și module este una dintre pietrele de temelie ale programării structurate, care a fost paradigma dominantă timp de câteva decenii înainte de apariția OOP.

Probleme de programare structurată

Pe măsură ce aplicațiile au crescut, programarea structurată a început să se lupte. Proiectele deveneau prea complexe. Programele s-au schimbat. Au fost implicați mai mulți programatori. Complexitatea a crescut. Costurile au crescut vertiginos, programul s-a mutat mai departe și a urmat colapsul.

Analiza motivelor acestor eșecuri a evidențiat deficiențele paradigmei procedurale. Indiferent cât de bine este implementată o abordare de programare structurată, aplicațiile mari devin excesiv de complexe.

Care sunt cauzele acestor probleme asociate cu limbajele procedurale? În primul rând, funcțiile au acces nelimitat la datele globale. În al doilea rând, procedurile și valorile care nu au legătură nu modelează bine lumea reală.

Când luăm în considerare aceste aspecte în contextul unui program de inventariere, unul dintre cele mai importante elemente de date globale este populația unităților contabile. Diverse funcții le pot accesa pentru a introduce o nouă valoare, a o afișa, a o modifica etc.

Acces nelimitat

Într-un program scris, de exemplu, în C, există două tipuri de date. Cele locale sunt ascunse în interiorul funcției și nu sunt utilizate de alte proceduri.

Când două sau mai multe funcții trebuie să acceseze aceleași date, acestea din urmă trebuie să fie globale. Astfel, de exemplu, sunt informații despre elementele luate în considerare. Datele globale pot fi accesate prin orice procedură.

Un program mare are multe funcții și multe elemente globale. Problema paradigmei procedurale este că aceasta duce la și mai multe potențiale conexiuni între ele.

Un număr atât de mare de conexiuni ridică mai multe dificultăți. În primul rând, este dificilă înțelegerea structurii programului. În al doilea rând, este dificil să faci schimbări. O modificare a unui element de date global poate necesita ajustări ale tuturor funcțiilor care îl accesează.

De exemplu, într-un program de contabilitate, cineva decide că codul articolului pentru care se ia în considerare nu trebuie să fie format din 5 cifre, ci din 12. Acest lucru va necesita schimbarea de la scurt la lung. Acum, funcțiile legate de cod trebuie modificate pentru a funcționa cu noul format.

Atunci când elementele se modifică într-o aplicație mare, este dificil de spus care proceduri au acces la ele. Dar chiar dacă acest lucru este descoperit, modificarea acestora poate duce la funcționarea incorectă a altor date globale. Totul este conectat la orice altceva, așa că o schimbare într-un loc va reverbera în altul.

Simulare în lumea reală

A doua și mai importantă problemă a paradigmei procedurale este că aranjarea datelor și funcțiilor individuale nu modelează bine lucrurile în lumea reală. Aici avem de-a face cu obiecte precum oameni și mașini. Nu arată ca date sau funcții. Obiectele reale complexe au atribute și comportament.

Atribute

Exemple de atribute (uneori numite caracteristici) pentru oameni sunt culoarea ochilor și titlul postului, iar pentru mașini cai putere și numărul de uși. După cum se dovedește, atributele din lumea reală sunt echivalente cu datele dintr-un program. Au semnificații specifice, cum ar fi albastru (culoarea ochilor) sau patru (număr de uși).

Comportament

Comportamentul este ceea ce obiectele din lumea reală produc ca răspuns la un fel de influență. Dacă îi ceri șefului tău o creștere de salariu, răspunsul va fi „da” sau „nu”. Dacă apăsați frâna, mașina se va opri. Vorbirea și oprirea sunt exemple de comportament. Un comportament este ca o procedură: este chemat să facă ceva și îl face. Astfel, datele și funcțiile prin ele însele nu modelează în mod eficient obiectele din lumea reală.

Soluţie

Un obiect în POO este reprezentat ca o colecție de date și funcții. Numai procedurile, numite funcții membre în C++, vă permit să recuperați valorile acestuia. Datele sunt ascunse și protejate împotriva schimbărilor. Valorile și funcțiile sunt încapsulate într-un singur întreg. Încapsularea și ascunderea sunt termenii principali în descrierea limbajelor OO.

Dacă trebuie să modificați datele, știți exact ce funcții interacționează cu acestea. Nicio altă procedură nu le poate accesa. Acest lucru facilitează scrierea, depanarea și întreținerea programului.

O aplicație constă de obicei din mai multe obiecte care interacționează între ele prin apelarea funcțiilor membre.

Astăzi, cea mai utilizată programare) este C++ (plus-plus). Java nu are unele caracteristici, cum ar fi indicatori, șabloane și moștenire multiplă, ceea ce îl face mai puțin puternic și versatil decât C++. C# nu a atins încă popularitatea C++.

Trebuie remarcat faptul că așa-numitele funcții membre în C++ sunt numite metode în alte limbaje orientate pe obiecte, cum ar fi Smalltalk. Elementele de date se numesc atribute. Apelarea unei metode pe un obiect înseamnă trimiterea unui mesaj.

Analogie

Vă puteți imagina obiectele ca departamente ale unei companii. În majoritatea organizațiilor, angajații nu lucrează în HR într-o zi, nu lucrează salariile în următoarea, iar apoi petrec o săptămână lucrând cu amănuntul. Fiecare departament are propriul personal cu responsabilități clar atribuite. Există și date proprii: indicatori de salariu, vânzări, evidența angajaților etc. Oamenii din departamente lucrează cu propriile informații. Separarea unei companii facilitează monitorizarea activităților acesteia și menținerea integrității datelor. Departamentul de contabilitate este responsabil de Dacă trebuie să știi suma totală a salariilor plătite în filiala de sud în luna iulie, nu este nevoie să scotoci prin arhive. Este suficient să trimiteți o notă persoanei responsabile, să așteptați până când această persoană obține acces la date și să trimiteți un răspuns cu informațiile solicitate. Acest lucru asigură conformitatea cu reglementările și absența interferențelor externe. În același mod, un obiect din OOP oferă organizarea unei aplicații.

Trebuie amintit că orientarea obiectelor nu se referă la detaliile modului în care funcționează programul. Majoritatea instrucțiunilor C++ corespund operatorilor din limbaje procedurale, cum ar fi C. Într-adevăr, funcțiile membre din C++ sunt foarte asemănătoare cu funcțiile din C. Numai contextul mai larg va determina dacă o instrucțiune este procedurală sau orientată pe obiecte.

Obiect în POO: Definiție

Când luăm în considerare o problemă de programare într-un limbaj orientat pe obiecte, în loc să punem întrebări despre împărțirea ei în funcții separate, se pune problema împărțirii acesteia în obiecte. Gândirea OOP face dezvoltarea aplicațiilor mult mai ușoară. Acest lucru se întâmplă ca urmare a similitudinii dintre software și obiectele reale.

Ce lucruri devin obiecte în POO? Mai jos sunt categorii tipice.

Un obiect fizic în POO este:

• transport în modele de flux;
• elemente electrice în programele de proiectare a circuitelor;
• ţări în modelul economic;
• aeronave în sistemul de control al traficului aerian.

Elemente ale mediului de calculator al utilizatorului:

• meniul;
• fereastră;
• grafice (linie, dreptunghi, cerc);
• tastatură, mouse, imprimantă, unități de disc.

• muncitorii;
• elevi;
• clienti;
• vânzători.

• Registrul mare;
• afaceri private;
• dicţionar;
• tabelul latitudinilor și longitudinilor zonelor populate.

Legătura dintre obiectele din lumea reală și OOP a fost rezultatul combinației de funcții și date: au revoluționat programarea. Nu există o corespondență atât de strânsă în limbile procedurale.

Clasă

Obiectele din OOP sunt membri ai claselor. Ce înseamnă? Limbajele de programare au tipuri de date încorporate. Tipul int, adică un număr întreg, este predefinit în C++. Puteți declara câte variabile int doriți.

Un set de obiecte din aceeași clasă este definit în mod similar. Definește funcțiile și datele incluse în obiectele sale fără a le crea, la fel cum int nu creează variabile.

O clasă în POO este o descriere a unui număr de obiecte similare. Prince, Sting și Madonna sunt cântăreți. Nu există nimeni cu acest nume, dar oamenii pot fi numiți așa dacă au caracteristicile adecvate. Un obiect OOP este o instanță a unei clase.

Moştenire

În viață, clasele sunt împărțite în subclase. De exemplu, animalele sunt împărțite în amfibieni, mamifere, păsări, insecte etc.

Principiul acestui tip de împărțire este că fiecare subclasă are caracteristici comune cu clasa din care descinde. Toate mașinile au roți și motor. Acestea sunt caracteristicile definitorii ale vehiculelor. Pe lângă caracteristicile generale, fiecare subclasă are propriile caracteristici. Autobuzele au o mulțime de locuri, iar camioanele au spațiu pentru a transporta încărcături grele.

De asemenea, o clasă de bază poate deveni părintele mai multor subclase derivate, care pot fi definite pentru a-și împărtăși caracteristicile în timp ce adaugă propriile lor. Moștenirea este ca o funcție care simplifică un program procedural. Dacă mai multe bucăți de cod fac aproape același lucru, puteți extrage elementele comune și le puteți pune într-o singură procedură. Trei părți ale aplicației pot apela o funcție pentru a efectua acțiuni comune, dar își pot efectua și propriile operații. În mod similar, o clasă de bază conține date comune unui grup de clase derivate. La fel ca și funcțiile, moștenirea scurtează un program orientat pe obiecte și clarifică relațiile dintre elementele sale.

Reutilizați

Odată ce o clasă a fost creată și depanată, aceasta poate fi partajată cu alți programatori pentru a fi reutilizată în propriile aplicații. Este ca o bibliotecă de funcții care pot fi incluse în diferite aplicații.

În POO, moștenirea este o extensie a ideii de reutilizare. Dintr-o clasă existentă, fără a o modifica, puteți crea una nouă cu adăugarea altor funcții. Ușurința de a reutiliza software-ul existent este un avantaj important al OOP. Se crede că acest lucru oferă profituri sporite ale investiției inițiale.

Crearea de noi tipuri de date

Obiectele sunt utile pentru crearea de noi tipuri de date. Să presupunem că un program folosește valori bidimensionale (de exemplu, coordonate sau latitudine și longitudine) și doriți să exprimați operații cu ele folosind operații aritmetice:

poziție1 = poziție + origine,

unde și originea sunt perechi de valori numerice independente. Crearea unei clase care include aceste două valori și declararea variabilelor sale ca obiecte creează un nou tip de date.

Polimorfism, suprasolicitare

Operatorii = (egal) și + (plus) utilizați în aritmetica pozițională de mai sus nu funcționează în același mod ca și cu tipurile încorporate, cum ar fi int. Obiectele de poziție etc. nu sunt predefinite, ci mai degrabă definite programatic. Cum știu acești operatori cum să le gestioneze? Răspunsul este că li se pot atribui noi modele de comportament. Aceste operațiuni vor fi funcții membre ale clasei Poziție.

Utilizarea operatorilor sau a procedurilor în funcție de ceea ce aceștia operează se numește polimorfism. Când unui operator existent, cum ar fi + sau =, i se oferă posibilitatea de a lucra cu un nou tip de date, se spune că este supraîncărcat. Supraîncărcarea în OOP este un tip de polimorfism. Este caracteristica sa importantă.

Cartea despre POO „Programare orientată pe obiecte pentru manechin” va permite tuturor să se familiarizeze cu acest subiect mai detaliat.

Principii de bază și etapele orientate pe obiecte

programare

În teoria programării, OOP este definită ca o tehnologie pentru crearea unui software complex, care se bazează pe reprezentarea unui program ca o colecție de obiecte, fiecare dintre acestea fiind o instanță de un anumit tip (clasă), iar clasele formează o ierarhie cu

moștenirea proprietăților.

Interacțiunea obiectelor software într-un astfel de sistem se realizează prin transmiterea de mesaje.

Notă. Această reprezentare a programului a fost folosită pentru prima dată în limbajul de simulare pentru sisteme complexe Simula, care a apărut în anii 60.

Modul de reprezentare a unui program, care este firesc pentru limbaje de modelare, a fost dezvoltat într-un alt limbaj de modelare specializat - limbajul Smalltalk (anii 70), apoi a fost

Pagina 2 din 51

Principiile de bază ale POO

utilizat în versiuni noi ale limbajelor de programare universale, cum ar fi Pascal, C++,

Principalul avantaj al OOP- reducerea numărului de apeluri intermodule și reducerea cantității de informații transferate între module;

comparativ cu programarea modulară. Acest lucru se realizează prin localizarea și integrarea mai completă a datelor cu rutinele de procesare,

care permite dezvoltarea practic independentă a părților individuale

(obiectele) programului.

În plus, abordarea obiect oferă noi instrumente de dezvoltare tehnologică, cum ar fi moștenire, polimorfism, compoziție, umplere,

permițându-vă să construiți obiecte complexe din altele mai simple. Ca urmare, rata de reutilizare a codului crește semnificativ,

Devine posibil să se creeze biblioteci de obiecte pentru diverse aplicații, iar dezvoltatorilor li se oferă oportunități suplimentare de a crea sisteme de complexitate crescută.

Principalul dezavantaj al OOP este o ușoară scădere a performanței datorită unei organizări mai complexe a sistemului software.

OOP se bazează pe următoarele principii: abstractizare,

restricție de acces, modularitate, ierarhie, tastare, paralelism,

durabilitate.

Să ne uităm la ce este fiecare principiu.

A b p s t r a g e- procesul de izolare a abstracțiilor în domeniul unei sarcini Abstracția este un set de caracteristici esențiale ale unui obiect care îl deosebesc de toate celelalte tipuri de obiecte.

astfel, ele definesc în mod clar trăsăturile unui obiect dat din punctul de vedere al examinării și analizei ulterioare. Conform definiției, abstracția folosită a unui obiect real depinde în mod semnificativ de problema rezolvată: într-un caz ne va interesa forma obiectului, în altul greutatea, în

al treilea - materialele din care este făcut, al patrulea - legea mișcării

Pagina 3 din 51

Principiile de bază ale POO

subiect, etc. Nivelul modern de abstractizare presupune unificarea tuturor proprietăților de abstractizare (atât cele referitoare la starea obiectului analizat,

şi determinarea comportamentului acestuia) într-o singură unitate de program un anumit

tip abstract (clasa).

Limitarea accesului- ascunderea elementelor individuale ale implementării abstracției care nu afectează caracteristicile esențiale ale acesteia în ansamblu.

Necesitatea de a restricționa accesul necesită o distincție între două părți în descrierea abstractizării:

interfață - un set de elemente de implementare a abstractizării accesibile din exterior (principalele caracteristici ale stării și comportamentului);

implementare - un set de elemente ale implementării unei abstracții care sunt inaccesibile din exterior (organizarea internă a abstracției și mecanismele de implementare a comportamentului acesteia).

Restricționarea accesului în POO permite dezvoltatorului:

∙ realizează construcția sistemului în etape, fără a fi distras de caracteristicile de implementare ale abstracțiilor utilizate;

∙ este ușor să modificați implementarea obiectelor individuale, care într-un sistem bine organizat nu vor necesita modificări ale altor obiecte.

Combinația de a combina toate proprietățile unui obiect (componentele stării și comportamentului său) într-o singură abstracție și restricționarea accesului la implementarea acestor proprietăți se numește încapsulare.

MODULARITATE- principiul dezvoltării unui sistem software,

sugerând implementarea sa sub formă de piese separate (module). La descompunerea unui sistem în module, este de dorit să se combine părți legate logic, asigurând, dacă este posibil, o reducere a numărului de conexiuni externe între module. Principiul este moștenit de la

Pagina 4 din 51

Principiile de bază ale POO

programarea modulară, urmând-o simplifică proiectarea și

depanarea programului.

Ierarhia este un sistem ordonat sau ordonat de abstracțiuni.

Principiul ierarhiei presupune utilizarea ierarhiilor în dezvoltarea sistemelor software.

OOP utilizează două tipuri de ierarhie.

Ierarhie „întreg/parte”- indică faptul că unele abstracții sunt activate

în abstracția în cauză ca părțile sale, de exemplu, o lampă este formată dintr-o bază, un filament incandescent și un bec. Această versiune a ierarhiei este utilizată în procesul de partiționare a sistemului în diferite etape de proiectare (la nivel logic - la descompunerea domeniului subiectului în obiecte, la nivel fizic - la descompunerea sistemului în module și la separarea proceselor individuale în un sistem multiproces).

Ierarhie „general/privat”- arată că o abstractizare este un caz special al unei alte abstracțiuni, de exemplu, „masa de sufragerie -

un anumit tip de masă” și „mesele sunt un anumit tip de mobilier”. Folosit pentru

dezvoltarea structurii claselor, atunci când clasele complexe sunt construite pe baza celor mai simple prin adăugarea lor de noi caracteristici și, eventual, clarificarea celor existente.

Unul dintre cele mai importante mecanisme ale POO este moștenirea proprietăților în ierarhia public/privat. Moștenirea este o relație între abstracții atunci când una dintre ele folosește o parte structurală sau funcțională a altei sau mai multe alte abstracțiuni (simple și, respectiv, multiple).

moştenire).

TIPZATION - o restricție impusă proprietăților obiectelor și

împiedicând interschimbabilitatea abstracțiilor de diferite tipuri (sau reducând foarte mult posibilitatea unei astfel de înlocuiri). În limbaje puternic tipizate, pentru fiecare obiect de program (variabilă, subrutină, parametru etc.)

declară un tip care definește un set de operații pe

Pagina 5 din 51

Principiile de bază ale POO

obiect software corespunzător. Limbajele de programare bazate pe Pascal discutate mai jos folosesc stricte, iar cele bazate pe C -

grad mediu de tipificare.

Utilizarea principiului de tastare asigură:

∙ detectarea timpurie a erorilor asociate cu operațiuni nevalide asupra obiectelor program (erorile sunt detectate în etapa de compilare a programului la verificarea admisibilității efectuării unei anumite operații asupra unui obiect program);

∙ simplificarea documentației;

∙ capacitatea de a genera cod mai eficient.

Un tip poate fi asociat cu un obiect software în mod static (tipul obiectului este determinat în timpul compilării - legarea timpurie)și dinamic (tipul obiectului este determinat numai în timpul execuției programului - legarea tardivă). Implementarea legăturii tardive într-un limbaj de programare vă permite să creați variabile - pointeri către obiecte aparținând unor clase diferite (obiecte polimorfe), care extinde semnificativ capacităţile limbii.

P a r l l e l i s m- proprietatea mai multor abstracții de a fi într-o stare activă în același timp, i.e. efectua unele operatii.

Există o serie de sarcini, a căror rezolvare necesită executarea simultană a anumitor secvențe de acțiuni. Pentru astfel de sarcini

de exemplu, sarcini legate de controlul automat al mai multor procese.

Paralelismul real se realizează numai la implementarea sarcinilor de acest tip pe sisteme multiprocesor, când este posibil să se execute fiecare proces pe un procesor separat. Sistemele cu un singur procesor simulează paralelismul prin împărțirea timpului procesorului între sarcinile de gestionare a diferitelor procese. În funcție de tipul de sistem de operare utilizat (un singur program sau multi-program)

Pagina 6 din 51

Principiile de bază ale POO

partajarea timpului poate fi realizată fie de sistemul în curs de dezvoltare (ca în

MS DOS) sau sistemul de operare utilizat (ca în sistemele Windows).

Stabilitate- proprietatea unei abstracții de a exista în timp indiferent de procesul care a generat un obiect software dat, și/sau în spațiu, deplasându-se din spațiul de adrese în care a fost creat.

Sunt:

∙ obiecte temporare care stochează rezultate intermediare ale anumitor acțiuni, cum ar fi calcule;

∙ obiecte locale care există în interiorul subrutinelor, a căror durată de viață este calculată de la apelul subrutinei până la finalizarea acestuia;

∙ obiecte globale care există în timp ce programul este încărcat în memorie;

∙ obiecte salvate, ale căror date sunt stocate în fișiere de memorie externă între sesiunile de program.

Toate principiile de mai sus sunt implementate într-o măsură sau alta în diferite versiuni ale limbajelor orientate pe obiecte.

Limbaje de programare orientate pe obiecte orientat pe obiecte, dacă implementează primele patru din cele șapte principii discutate.

Modelele de obiecte Delphi și C++Builder ocupă un loc aparte. Aceste modele generalizează experiența OOP pentru MS DOS și includ câteva caracteristici noi,

asigurând crearea eficientă a unor sisteme mai complexe. Pe baza acestor modele au fost create medii vizuale pentru dezvoltarea aplicațiilor Windows.

Complexitatea programării sub Windows a fost depășită semnificativ

redus prin crearea unor biblioteci speciale de obiecte care „ascundea” multe elemente ale tehnicilor de programare.

Pagina 7 din 51

Principiile de bază ale POO

Etapele dezvoltării sistemelor software folosind POO.

Procesul de dezvoltare software folosind POO include patru etape: analiză, proiectare, evoluție, modificare.

Să ne uităm la aceste etape.

Analiza . Scopul analizei este descrierea cea mai completă a problemei. În această etapă se realizează o analiză a domeniului problemei, se realizează o descompunere obiect a sistemului în curs de dezvoltare și se determină cele mai importante caracteristici ale comportamentului obiectelor (descrierea abstracțiilor). Pe baza rezultatelor analizei, se elaborează o diagramă structurală a produsului software, care prezintă principalele obiecte și mesaje transmise între ele și, de asemenea, descrie abstracțiile.

Design.

design logic,în care deciziile luate sunt practic independente de condițiile de funcționare (sistemul de operare și echipamentele utilizate);

design fizic,în care trebuie luaţi în considerare aceşti factori.

Design logic este de a dezvolta o structură de clasă:

sunt definite câmpuri pentru stocarea componentelor stării obiectelor și algoritmi ai metodelor care implementează aspecte ale comportamentului obiectelor. În acest caz, sunt utilizate tehnicile de dezvoltare a clasei discutate mai sus (moștenire,

compoziție, conținut, polimorfism etc.). Rezultatul este o ierarhie sau o diagramă de clasă care arată relațiile dintre clase și o descriere a claselor.

Design fizic include combinarea descrierilor claselor în module, alegerea schemei de conectare a acestora (dispoziție statică sau dinamică), determinarea modalităților de interacțiune cu echipamentele, cu

sistem de operare și/sau alt software (de exemplu,

baze de date, programe de rețea), asigurarea sincronizării proceselor pentru sistemele de procesare paralelă etc.

Pagina 8 din 51

Principiile de bază ale POO

Evoluția sistemelor. Acesta este un proces de implementare pas cu pas și

conectarea claselor la proiect. Procesul începe cu crearea unui program de bază sau a unui proiect pentru un viitor produs software. Apoi, clasele sunt implementate și conectate astfel încât să creeze un aspect brut, dar, dacă este posibil,

un prototip funcțional al viitorului sistem. Este testat și depanat.

De exemplu, un astfel de prototip poate fi un sistem care include implementarea interfeței principale a unui produs software (mesajele nu sunt transmise către o parte a sistemului care nu este încă disponibilă). Drept urmare, primim un prototip funcțional al produsului, care, de exemplu, poate fi arătat clientului pentru a clarifica cerințele. Apoi, următorul grup de clase este conectat la sistem, de exemplu, asociat cu implementarea unui anumit element de meniu.

Versiunea rezultată este, de asemenea, testată și depanată și așa mai departe, până când toate capabilitățile sistemului sunt realizate.

Utilizarea unei implementări în etape simplifică foarte mult testarea și depanarea unui produs software.

Modificare. Este procesul de adăugare de noi funcționalități sau de modificare a proprietăților sistemului existente. De obicei,

modificările afectează implementarea clasei, lăsând interfața acesteia neschimbată, ceea ce atunci când se folosește OOP, de obicei, se face fără prea multe probleme, deoarece procesul de modificări afectează zona locală.

Schimbarea interfeței nu este, de asemenea, o sarcină foarte dificilă, dar soluția ei poate presupune necesitatea coordonării proceselor de interacțiune între obiecte, ceea ce va necesita modificări în alte clase ale programului. Cu toate acestea, reducerea numărului de parametri din interfață în comparație cu programarea modulară simplifică foarte mult acest proces.

Simplitatea modificării face relativ ușoară adaptarea sistemelor software la condițiile de operare în schimbare, ceea ce crește durata de viață a sistemelor, a căror dezvoltare necesită timp și resurse materiale enorme.

Pagina 9 din 51

Principiile de bază ale POO

O caracteristică specială a OOP este că un obiect sau un grup de obiecte poate fi dezvoltat separat și, prin urmare, proiectarea lor poate fi în etape diferite. De exemplu, clasele de interfață au fost deja implementate, dar structura claselor de domeniu este încă în curs de perfecționare.

De obicei, proiectarea începe atunci când orice fragment al domeniului subiectului este descris suficient de complet în procesul de analiză.

Vom începe analiza tehnicilor de bază ale abordării obiectelor cu descompunerea obiectului.

Descompunerea obiectului

După cum am menționat mai sus, atunci când utilizați tehnologia OOP, soluția este reprezentată sub formă rezultatul interacțiunii elementelor funcționale individuale un sistem care simulează procese,

care apar în domeniul subiectului sarcinii.

Într-un astfel de sistem, fiecare element funcțional, după ce a primit o influență de intrare (numită mesaj) în procesul de rezolvare a problemei,

efectuează acțiuni predeterminate (de exemplu, își poate schimba propria stare, poate efectua unele calcule, desenează o fereastră sau un grafic și, la rândul său, poate influența alte elemente). Procesul de rezolvare a problemelor este controlat de succesiune de mesaje. Trecând aceste mesaje de la element la element, sistemul efectuează acțiunile necesare.

Elemente funcționale ale sistemului, ale căror parametri și comportament sunt determinați de starea problemei și au un comportament independent

(adică, „capabil” să efectueze anumite acțiuni în funcție de mesajele primite și de starea elementului) sunt numite obiecte.

Procesul de reprezentare a domeniului problemei ca o colecție de obiecte care schimbă mesaje este numit descompunerea obiectului.

Pagina 10 din 51

Principiile de bază ale POO

Pentru a înțelege ce obiecte și mesaje sunt discutate atunci când se efectuează descompunerea obiectelor în fiecare caz specific, trebuie amintit că abordarea obiectului a fost propusă inițial pentru dezvoltarea modelelor de simulare a comportamentului sistemelor complexe. Setul de obiecte ale unor astfel de sisteme este de obicei determinat prin analiza proceselor simulate.

Exemplu. Descompunerea obiectului (model de simulare

benzinărie). Să fim interesați de dependența lungimii cozii la o benzinărie de numărul de benzinării, de parametrii de serviciu ai fiecărei benzinării și de intensitatea solicitărilor de realimentare (luăm în considerare același tip de combustibil).

Problemele de acest tip sunt de obicei rezolvate folosind modele de simulare. Modelul simulează programatic un proces real cu parametri dați, înregistrând simultan caracteristicile acestuia. Prin repetarea procesului de simulare de multe ori cu valori diferite ale parametrilor de serviciu sau primirea cererilor, cercetătorul obține valori specifice ale caracteristicilor pe care sunt construite graficele dependențelor analizate.

Procesul de funcționare a unei benzinării cu trei stații de alimentare poate fi reprezentat sub forma unei diagrame.