Polimorfismul genetic este o condiție în care există o diversitate pe termen lung a genelor, dar frecvența celei mai rare gene din populație este mai mare de unu la sută. Menținerea acestuia are loc datorită mutației constante a genelor, precum și recombinării lor constante. Potrivit cercetărilor efectuate de oamenii de știință, polimorfismul genetic a devenit larg răspândit, deoarece pot exista câteva milioane de combinații de gene.

Stoc mare

O mai bună adaptare a unei populații la un mediu nou depinde de o mare cantitate de polimorfism, iar în acest caz evoluția are loc mult mai rapid. Nu este practic să se estimeze întregul număr de alele polimorfe folosind metode genetice tradiționale. Acest lucru se datorează faptului că prezența unei anumite gene în genotip se realizează prin încrucișarea unor indivizi care au caracteristici fenotipice diferite determinate de genă. Dacă știți ce parte a unei anumite populații este formată din indivizi cu fenotipuri diferite, atunci devine posibil să se determine numărul de alele de care depinde formarea unei anumite trăsături.

Cum a început totul?

Genetica a început să se dezvolte rapid în anii 60 ai secolului trecut, atunci au început să fie folosite enzimele din geluri, ceea ce a făcut posibilă determinarea polimorfismului genetic. Ce este această metodă? Cu ajutorul ei proteinele se mișcă într-un câmp electric, care depinde de mărimea proteinei care este mutată, de configurația acesteia, precum și de încărcarea totală în diferite părți ale gelului. După aceasta, în funcție de locația și numărul de pete care apar, se identifică substanța identificată. Pentru a evalua polimorfismul proteinelor într-o populație, merită să examinăm aproximativ 20 sau mai mulți loci. Apoi, folosind o metodă matematică, se determină numărul și raportul de homo- și heterozigoți. Conform cercetărilor, unele gene pot fi monomorfe, în timp ce altele pot fi neobișnuit de polimorfe.

Tipuri de polimorfism

Conceptul de polimorfism este extrem de larg; include o variantă tranzitorie și una echilibrată. Aceasta depinde de valoarea selectivă a genei și de selecția naturală, ceea ce pune presiune asupra populației. În plus, poate fi genetic și cromozomial.

Polimorfismul genelor și cromozomiale

Polimorfismul genelor este reprezentat în organism de mai multe alele; un exemplu izbitor în acest sens este sângele. Cromozomiale reprezintă diferențele în interiorul cromozomilor care apar din cauza aberațiilor. În același timp, există diferențe în regiunile heterocromatice. În absența unei patologii care va duce la afectare sau moarte, astfel de mutații sunt neutre.

Polimorfismul tranzițional

Polimorfismul tranzițional apare atunci când o alelă care a fost odinioară comună este înlocuită într-o populație cu o alta care oferă purtătorului său o mai mare adaptabilitate (numită și alelism multiplu). Cu o anumită varietate, există o schimbare direcțională a procentului de genotipuri, datorită căreia are loc evoluția și se realizează dinamica acesteia. Fenomenul mecanismului industrial poate fi un bun exemplu care caracterizează polimorfismul tranzițional. Ceea ce este este arătat de un fluture simplu, care, odată cu dezvoltarea industriei, și-a schimbat culoarea albă a aripilor în închisă. Acest fenomen a început să fie observat în Anglia, unde peste 80 de specii de fluturi s-au transformat de la flori crem pal la flori închise, lucru care a fost observat pentru prima dată după 1848 la Manchester, datorită dezvoltării rapide a industriei. Deja în 1895, peste 95% dintre molii au căpătat o colorare închisă a aripilor lor. Astfel de schimbări sunt asociate cu faptul că trunchiurile copacilor au devenit mai fumurii, iar fluturii de culoare deschisă au devenit o pradă ușoară pentru sturzi și robi. Modificările au avut loc datorită alelelor melanistice mutante.

Polimorfism echilibrat

Definiția „polimorfismului echilibrat” caracterizează absența unei schimbări a oricăror rapoarte numerice ale diferitelor forme de genotipuri într-o populație care se află în condiții de mediu stabile. Aceasta înseamnă că de la generație la generație raportul rămâne același, dar poate fluctua ușor în cadrul unei anumite valori, care este constantă. În comparație cu polimorfismul tranzițional, echilibrat - ce este? Este în primul rând un proces evolutiv static. I. I. Shmalhausen în 1940 i-a dat și numele heteromorfism de echilibru.

Exemplu de polimorfism echilibrat

Un exemplu clar de polimorfism echilibrat este prezența a două sexe la multe animale monogame. Acest lucru se datorează faptului că au avantaje selective egale. Raportul lor într-o singură populație este întotdeauna egal. Dacă există poligamie într-o populație, raportul selectiv al reprezentanților ambelor sexe poate fi perturbat, caz în care reprezentanții unui sex pot fi fie complet distruși, fie sunt eliminați din reproducere într-o măsură mai mare decât reprezentanții sexului opus.

Un alt exemplu ar fi grupa sanguină conform sistemului ABO. În acest caz, frecvența diferitelor genotipuri în diferite populații poate fi diferită, dar, în același timp, nu își schimbă constanța de la o generație la alta. Mai simplu spus, niciun genotip nu are un avantaj selectiv față de altul. Potrivit statisticilor, bărbații cu prima grupă de sânge au o speranță de viață mai mare decât alți membri ai sexului puternic cu alte grupe de sânge. Odată cu aceasta, riscul de a dezvolta ulcer duodenal în prezența primului grup este mai mare, dar se poate perfora, iar acest lucru va cauza moartea dacă asistența este întârziată.

Echilibrul genetic

Această stare fragilă poate fi perturbată într-o populație ca o consecință a apariției și trebuie să apară cu o anumită frecvență și în fiecare generație. Studiile au arătat că polimorfismele genelor sistemului hemostatic, a căror decodare face clar dacă procesul evolutiv promovează aceste modificări sau, dimpotrivă, le contracarează, sunt extrem de importante. Dacă urmăriți cursul procesului mutant într-o anumită populație, puteți judeca și valoarea acestuia pentru adaptare. Poate fi egal cu unu dacă mutația nu este exclusă în timpul procesului de selecție și nu există obstacole în calea răspândirii acesteia.

Majoritatea cazurilor arată că valoarea unor astfel de gene este mai mică de unu, iar în cazul incapacității unor astfel de mutanți de a se reproduce, totul se reduce la 0. Mutațiile de acest fel sunt eliminate în procesul de selecție naturală, dar acest lucru nu nu exclude modificări repetate ale aceleiași gene, care compensează eliminarea care se realizează prin selecție. Atunci se ajunge la echilibru, pot apărea gene mutante sau, dimpotrivă, pot dispărea. Acest lucru duce la un proces echilibrat.

Un exemplu care poate caracteriza clar ceea ce se întâmplă este anemia cu celule falciforme. În acest caz, o genă mutantă dominantă într-o stare homozigotă contribuie la moartea timpurie a organismului. Organismele heterozigote supraviețuiesc, dar sunt mai susceptibile la boala malariei. Polimorfismul echilibrat al genei anemiei falciforme poate fi urmărit în zonele de răspândire a acestei boli tropicale. Într-o astfel de populație, homozigoții (indivizi cu aceleași gene) sunt eliminați, iar selecția acționează în favoarea heterozigoților (indivizi cu gene diferite). Datorită selecției multi-vectori care are loc în bazinul genetic al populației, genotipurile sunt menținute în fiecare generație, ceea ce asigură o mai bună adaptabilitate a organismului la condițiile de mediu. Alături de prezența genei anemiei falciforme, există și alte tipuri de gene care caracterizează polimorfismul. Ce dă asta? Răspunsul la această întrebare va fi un fenomen numit heterosis.

Mutații heterozigote și polimorfism

Polimorfismul heterozigot asigură absența modificărilor fenotipice în prezența mutațiilor recesive, chiar dacă acestea sunt dăunătoare. Dar, în același timp, se pot acumula într-o populație la un nivel ridicat, ceea ce poate depăși mutațiile dominante dăunătoare.

proces evolutiv

Procesul evolutiv este continuu, iar condiția sa este polimorfismul. Ceea ce înseamnă aceasta este adaptabilitatea constantă a unei anumite populații la habitatul său. Organismele de sexe diferite care trăiesc în cadrul aceluiași grup pot fi în stare heterozigotă și pot fi transmise din generație în generație timp de mulți ani. Odată cu aceasta, manifestarea lor fenotipică poate să nu existe - datorită rezervei uriașe de variabilitate genetică.

Gena fibrinogenului

În cele mai multe cazuri, cercetătorii consideră polimorfismul genei fibrinogenului ca un precursor al dezvoltării accidentului vascular cerebral ischemic. Dar în acest moment iese în prim-plan problema în care factorii genetici și dobândiți sunt capabili să influențeze dezvoltarea acestei boli. Acest tip de accident vascular cerebral se dezvoltă din cauza trombozei arterelor cerebrale, iar prin studierea polimorfismului genei fibrinogenului se pot înțelege multe procese, prin influențarea cărora boala poate fi prevenită. În prezent, oamenii de știință nu au studiat suficient conexiunile dintre modificările genetice și parametrii biochimici ai sângelui. Cercetările ulterioare vor face posibilă influențarea cursului bolii, schimbarea cursului acesteia sau pur și simplu prevenirea acesteia într-un stadiu incipient de dezvoltare.

Programare orientată pe obiecte(OOP) este o abordare a creării de programe bazată pe utilizarea claselor și a obiectelor care interacționează între ele.

O clasă (clasa java) descrie structura și comportamentul obiectelor. Un dispozitiv este descris printr-un set de caracteristici (proprietăți), iar comportamentul este descris printr-un set de operații (metode) disponibile pentru obiecte. Clasele pot fi create pe baza celor existente prin adăugarea sau suprascrierea proprietăților și metodelor.

Clasele reprezintă șabloanele prin care sunt construite obiectele. Obiectele sunt elemente de program care au un set similar de caracteristici și comportament (adică sunt elemente construite pe baza aceleiași clase). Fiecare obiect are o anumită stare, este determinată de valoarea tuturor proprietăților sale. Într-un program pot exista mai multe clase, iar obiectele din clase diferite pot interacționa între ele (prin metode).

Moștenire, se extinde

Moștenirea este o parte integrantă a Java. Când se folosește moștenirea, se ține cont de faptul că o nouă clasă care moștenește proprietățile clasei de bază (părinte) are toate proprietățile pe care le are părintele. Codul folosește operandul se extinde, urmat de numele clasei de bază. Aceasta deschide accesul la toate câmpurile și metodele clasei de bază.

Folosind moștenirea, este posibil să se creeze o „clasă java” generică care definește caracteristicile comune unui set de elemente înrudite. Apoi puteți moșteni din el și puteți crea clase suplimentare pentru care puteți defini caracteristici suplimentare care sunt unice pentru ele.

Clasa principală moștenită în Java se numește superclasă super. Clasa moștenitoare este numită subclasă. Astfel, o subclasă este o versiune specializată a unei superclase care moștenește toate proprietățile superclasei și adaugă propriile elemente unice.

Să luăm în considerare un exemplu de descriere a clasei java „un student Student, care are un prenume, prenume, vârstă și număr de grup. Vom crea o clasă de student pe baza super-clasei utilizatorului User, care are deja un prenume, un prenume și o vârstă definite:

Clasa publică User (int age; String firstName; String lastName; // Constructor public User(int age, String firstName, String lastName) ( this.age = age; this.firstName = prenume; this.lastName = lastName; ) )

Acum creăm o clasă separată Student, care moștenește proprietățile super-clasei. Când moșteniți o clasă, trebuie să suprascrieți și constructorii clasei părinte:

Clasa publică Student extinde Utilizator ( int group; // Constructor public Student(int age, String firstName, String lastName) ( super(varsta, prenume, prenume); ) boolean isMyGroup(int g) ( return g == grup; ) )

Cuvânt cheie se extinde arată că moștenim din clasa User.

Cuvânt cheie super

În constructorul clasei Student, numim constructorul clasei părinte prin operator super, trecându-i întregul set necesar de parametri. În Java cuvântul cheie super denotă o superclasă, adică Clasa din care derivă clasa curentă. Cuvântul cheie super poate fi folosit pentru a apela un constructor de superclasă și pentru a accesa un membru al superclasei ascuns de un membru al subclasei.

Să vedem cum se întâmplă moştenireîn ceea ce privește crearea obiectelor:

Student student = nou Student(18, „Kisa”, „Vorobyaninov”, 221);

Mai întâi, se deschide constructorul clasei Student, apoi se apelează constructorul superclasei User și apoi se execută operațiunile rămase din constructorul Student. Această secvență de acțiuni este destul de logică și vă permite să creați obiecte mai complexe pe baza unora mai simple.

O superclasă poate avea mai multe versiuni supraîncărcate ale constructorilor săi, astfel încât metoda super() poate fi apelată cu diferiți parametri. Programul va executa constructorul care se potrivește cu argumentele specificate.

A doua formă de cuvânt cheie super acționează ca un cuvânt cheie acest, doar în acest caz ne referim întotdeauna la superclasa subclasei în care este folosită. Forma generală este următoarea:

Aici membrul poate fi o metodă sau o variabilă de instanță. Această formă este potrivită în cazurile în care numele membrilor unei subclase ascund membrii unei superclase cu aceleași nume.

Clasa A ( int i; ) // moștenește din clasa A clasa B extinde A ( int i; // numele variabilei se potrivește și ascunde variabila i din clasa A B(int a, int b) ( super.i = a; // acces la variabila i din clasa A i = b; // accesează variabila i din clasa B ) void show() ( System.out.println("i din superclasa este " + super.i); System.out.println(" i în subclasă este " + i); ) ) clasa MainActivity ( B subClass = nou B(1, 2); subClass.show(); )

Ca rezultat, ar trebui să vedem în consolă:

I din superclasa este 1 i în subclasa este 2

Suprascrierea metodei, Override

Dacă într-o ierarhie de clasă, numele și semnătura tipului unei metode de subclasă se potrivesc cu atributele unei metode de superclasă, atunci metoda de subclasă înlocuiește metoda de superclasă. Când o metodă suprascrisă este apelată din subclasa sa, se va referi întotdeauna la versiunea acelei metode a subclasei. Și versiunea superclasă a metodei va fi ascunsă.

Dacă trebuie să accesați o versiune a unei metode suprascrise definită într-o superclasă, trebuie să utilizați cuvântul cheie super.

Nu confundați suprasolicitarea cu supraîncărcarea. Suprascrierea metodei are loc numai dacă numele și semnăturile de tip ale celor două metode sunt identice. În caz contrar, cele două metode sunt pur și simplu supraîncărcate.

Adnotarea a apărut în Java SE5 @Trece peste;. Dacă trebuie să suprascrieți o metodă, utilizați @Override și compilatorul va arunca o eroare dacă o supraîncărcați accidental în loc să o suprascrieți.

În Java, puteți moșteni doar de la o clasă.

Încapsulare

În informatică, încapsularea (în latină: en capsula) este împachetarea datelor și/sau funcțiilor într-un singur obiect.

Baza încapsulării în Java este clasa. Încapsularea înseamnă că câmpurile unui obiect nu sunt direct accesibile clienților săi - sunt ascunse accesului direct din exterior. Încapsularea protejează datele unui obiect de accesul nedorit, permițând obiectului să controleze accesul la datele sale.

Modificatori de acces

Când descrieți o clasă, sunt utilizați modificatori de acces. Modificatori de acces poate fi privit din perspectivă încapsulare deci si moştenire. Când sunt priviți din perspectiva încapsulării, modificatorii de acces vă permit să restricționați accesul nedorit la membrii clasei din exterior.

Membrii publici ai unei clase constituie o funcționalitate externă care este disponibilă altor clase. Membrii care sunt independenți de funcționalitatea externă sunt de obicei declarați privați, precum și metodele auxiliare care sunt doar detalii de implementare și nu sunt de natură universală. Ascunzând implementarea unei clase, puteți modifica logica internă a unei clase separate fără a modifica codul altor componente ale sistemului.

Este recomandabil să utilizați accesul la proprietățile clasei numai prin metodele sale (principiul fasole clase, „POJO”), care vă permite să validați valorile câmpurilor, deoarece accesul direct la proprietăți este extrem de dificil de urmărit, ceea ce înseamnă că li se pot atribui valori incorecte în etapa de execuție a programului. Acest principiu se referă la gestionarea datelor încapsulate și vă permite să schimbați rapid modul în care sunt stocate datele. Dacă datele sunt stocate nu în memorie, ci în fișiere sau într-o bază de date, atunci doar câteva metode dintr-o clasă vor trebui modificate, mai degrabă decât introducerea acestei funcționalități în toate părțile sistemului.

Codul programului scris folosind principiul încapsulării este mai ușor de depanat. Pentru a afla în ce moment din timp și cine a schimbat proprietatea obiectului care ne interesează, este suficient să adăugați informații de depanare la metoda obiectului prin care este accesată proprietatea acestui obiect. Când folosește accesul direct la proprietățile obiectului, programatorul ar trebui să adauge informații de depanare la toate secțiunile codului în care este folosit obiectul de interes.

Exemplu de descriere simplă a unui robot

Robot de clasă publică ( private double x = 0; // Coordonată X curentă dublu privat y = 0; // Coordonată Y curentă curs dublu privat = 0; // Curs curent (în grade) public double getX() ( return x; ) public void setX(double x) ( this.x = x; ) public double getY() ( return y; ) public void setY(double y) ( this.y = y; ) public double getCourse() ( return course; ) // Determinarea cursului public void setCourse(curs dublu) ( this.course = course; ) // Deplasarea la o distanță public void forward(int distance) ( // Accesarea câmpului obiect X x = x + distanță * Math.cos ( curs / 180 * Math.PI); // Acces la câmpul obiect Y y = y + distanță * Math.sin(curs / 180 * Math.PI); ) // Imprimă coordonatele robotului public void printCoordinates() ( System .out .println(x + "," + y); ) )

Exemplul de robot prezentat folosește seturi de metode începând cu a stabilitȘi obține. Această pereche de metode este adesea numită setter/getter. Aceste metode sunt folosite pentru a accesa câmpurile unui obiect. Numele metodelor se termină cu numele câmpului care începe cu o majusculă.

În metode a stabilit trecem valoarea printr-un parametru formal în procedură. În codul de procedură, atribuim o valoare unei variabile obiect/clasă folosind cuvântul cheie acest.

Acest.curs = curs...

Utilizarea cuvintelor cheie acest necesar, deoarece numele parametrului formal coincide cu numele variabilei obiect. Dacă numele ar fi diferite, ar fi posibil acest nu folosi.

Polimorfismul

Polimorfismul este unul dintre conceptele fundamentale în programarea orientată pe obiecte, împreună cu moștenirea și încapsularea. Cuvântul polimorfism este de origine greacă și înseamnă „având multe forme”. Pentru a înțelege ce înseamnă polimorfismul în legătură cu programarea orientată pe obiecte, luați în considerare un exemplu de creare a unui editor de grafică vectorială în care este necesar să folosiți un număr de clase sub forma unui set de primitive grafice - Pătrat, Linia, Cerc, Triunghi, etc. Fiecare dintre aceste clase trebuie să aibă o metodă definită a desena pentru a afișa primitiva corespunzătoare pe ecran.

Evident, va trebui să scrieți un cod care, pentru a afișa imaginea, va itera secvențial prin toate primitivele care trebuie afișate pe ecran și va apela metoda draw pe fiecare dintre ele.

O persoană care nu este familiarizată cu polimorfismul va crea cel mai probabil mai multe matrice: o matrice separată pentru fiecare tip primitiv și va scrie cod care iterează prin elementele din fiecare matrice secvenţial și apelează metoda draw pe fiecare element. Rezultatul va fi aproximativ următorul cod:

// Definirea tablourilor de primitive grafice Square s = new Square ; Linia l = linie nouă; Cercul c = cercul nou ; Triunghi t = triunghi nou; // Umpleți toate tablourile cu obiectele corespunzătoare. . . // Repetare în buclă prin toate celulele matricei. pentru (int i = 0; i< s.length; i++){ // вызов метода draw() в случае, если ячейка не пустая. if (s[i] != null) s.draw(); } for(int i = 0; i < l.length; i++){ if (l[i] != null) l.draw(); } for(int i = 0; i < c.length; i++){ if (c[i] != null) c.draw(); } for(int i = 0; i < t.length; i++){ if (t[i] != null) t.draw(); }

Dezavantajul codului scris mai sus este duplicarea unui cod aproape identic pentru a afișa fiecare tip de primitivă. De asemenea, este incomod faptul că, odată cu modernizarea ulterioară a editorului nostru grafic și adăugarea capacității de a desena noi tipuri de primitive grafice, de exemplu Text, Star etc., cu această abordare va trebui să schimbăm codul existent și să adăugăm definiții de noi matrice. acestuia, precum și prelucrarea elementelor conținute în acestea.

Folosind polimorfismul, puteți simplifica foarte mult implementarea unei astfel de funcționalități. În primul rând, să creăm o clasă părinte Shape comună pentru toate clasele noastre.

Clasa publică Shape ( public void draw() ( System.out.println("Stub"); ) )

După aceasta, creăm diferite clase de descendență: Pătrat, Linie, Cerc și Triunghi:

Clasa publică Point extinde Forma ( public void draw() ( System.out.println("Pătrat"); ) ) clasă publică Linia extinde Forma ( public void draw() ( System.out.println("Linie"); ) ) clasă publică Cercul extinde Forma ( public void draw() ( System.out.println("Cerc"); ) ) clasă publică Triunghi extinde Forma ( public void draw() ( System.out.println("Triunghi"); ) )

În descendenți am suprascris metoda draw. Ca rezultat, am obținut o ierarhie de clasă, care este prezentată în figură.

Acum să vedem caracteristica uimitoare a polimorfismului:

// Definirea și inițializarea tabloului Shape a = New Shape (new Shape(), new Triangle(), new Square(), new Circle()); // Buclă prin elementele matricei pentru(int i = 0; i< a.length; i++) { a[i].draw(); }

Următoarele rânduri vor fi imprimate pe consolă:

Cerc pătrat triunghi gol

În acest fel, fiecare clasă descendentă și-a numit propria metodă draw, în loc să apeleze metoda draw din clasa părinte Shape.

Polimorfismul este o prevedere a teoriei tipurilor, conform căreia numele (de exemplu, variabile) pot desemna obiecte din clase diferite, dar având un părinte comun. În consecință, orice obiect notat printr-un nume polimorf poate răspunde în felul său la un anumit set general de operații.

Supraîncărcare de metodă, supraîncărcare

În programarea procedurală există și conceptul de polimorfism, care diferă de mecanismul considerat în OOP. Polimorfismul procedural presupune posibilitatea creării mai multor proceduri sau funcții cu același nume, dar trecute numere sau tipuri diferite de parametri. Astfel de funcții cu același nume se numesc supraîncărcate, iar fenomenul în sine se numește supraîncărcare. Supraîncărcarea funcției există și în OOP și se numește supraîncărcare a metodei. Un exemplu de utilizare a supraîncărcării metodei în limbajul Java este clasa PrintWriter, care este folosită în special pentru tipărirea mesajelor către consolă. Această clasă are multe metode println care diferă prin tipurile și/sau numărul de parametri de intrare. Iată doar câteva dintre ele:

Void println() // merge la o linie nouă void println(boolean x) // afișează valoarea unei variabile booleene (adevărat sau fals) void println(String x) // afișează un șir - valoarea unui parametru de text

Polimorfismul este un principiu POO care vă permite să utilizați o singură interfață și diferiți algoritmi. Scopul polimorfismului, așa cum este aplicat OOP, este de a folosi un nume pentru a specifica diferite acțiuni. Executarea acțiunii va fi determinată de tipul de date.

Tipuri de polimorfism:

Static (determinat în timpul compilării). Supraîncărcarea funcțiilor, metodelor, operatorilor etc.

Dinamic (determinat în timpul rulării). Conține funcții și metode virtuale.

22. Moștenirea ca mecanism de implementare a polimorfismului și de creare a ierarhiilor de clasă. Tipuri de moștenire.

Moștenirea este un mecanism OOP prin care se creează noi clase pe baza celor existente. Aceste clase moștenesc proprietățile și comportamentul claselor de bază și pot dobândi altele noi. Acest lucru vă permite să reduceți dimensiunea programului și timpul de dezvoltare a acestuia. Polimorfismul ne permite să scriem programe pentru a gestiona o mare varietate de clase legate logic. Moștenirea și polimorfismul sunt tehnici eficiente pentru dezvoltarea de programe complexe.

Tipuri de moștenire: directă și indirectă, simplă și multiplă.

23. Clasele. De bază, derivată, polimorfă, abstractă, virtuală. Exemple.

O clasă este un tip de date special care descrie atât atributele datelor, cât și acțiunile efectuate asupra atributelor.

O clasă de bază este o clasă ai cărei membri sunt moșteniți.

O clasă derivată este o clasă care moștenește alți membri.

O clasă polimorfă este o clasă care conține metode virtuale.

O clasă abstractă este o clasă care conține metode pur virtuale.

O clasă virtuală este o clasă care, în timpul moștenirii multiple, nu este inclusă în clasele descendente, ci este înlocuită cu o referință în acestea, pentru a evita duplicarea.

24. Principiile legării timpurii și tardive.

Legarea este procedura de stabilire a unei conexiuni între un identificator utilizat într-un cod de program și obiectul fizic al acestuia (în general, orice componentă software: variabilă, procedură, modul, aplicație etc.)

Legarea timpurie este stabilirea unor astfel de conexiuni înainte ca programul să înceapă execuția. Aceasta înseamnă de obicei conectarea modulelor sursă și legarea modulului executabil de la modulele obiect în timpul procesului de compilare.

Legarea tardivă este stabilirea conexiunilor în timpul execuției programului. De obicei vorbim fie despre conexiuni dinamice (atunci când numai în timpul funcționării aplicației se stabilește ce obiecte vor fi necesare), fie despre formarea unor astfel de obiecte în timpul funcționării.

25. Utilizarea UML pentru specificare

26. Descrierea ierarhiilor de clase cu diagrame uml.

Relaţiile de clasă prin . Și arată diferite relații: directe, indirecte, multiple.

27. Clase tip șablon. Descriere în uml.

Un șablon de clasă este un instrument de limbaj C++ conceput pentru codificarea algoritmilor generalizați de clasă, fără referire la anumiți parametri (de exemplu, tipuri de date, dimensiuni de buffer, valori implicite).

Sintaxă:

șablon

clasa NAME_CLASS

NAME_CLASS B; //Apel

s_a_p 20 august 2008 la 19:09

Polimorfism pentru începători

• PHP

Polimorfismul este una dintre cele trei paradigme principale OOP. Pe scurt, polimorfismul este capacitatea unui obiect de a folosi metode dintr-o clasă derivată care nu există în momentul creării celei de bază. Pentru cei care nu cunosc în mod special OOP, acest lucru probabil sună complicat. Prin urmare, să ne uităm la utilizarea polimorfismului folosind un exemplu.

Formularea problemei

Să presupunem că site-ul are nevoie de trei tipuri de publicații - știri, anunțuri și articole. Sunt similare în anumite privințe - toate au un titlu și text, știrile și anunțurile au o dată. În unele privințe, ele sunt diferite - articolele au autori, știrile au surse, iar anunțurile au o dată după care devine irelevantă.

Cele mai simple opțiuni care vă vin în minte sunt să scrieți trei clase separate și să lucrați cu ele. Sau scrieți o clasă care va conține toate proprietățile inerente tuturor celor trei tipuri de publicații și vor fi folosite numai cele necesare. Dar pentru diferite tipuri, metodele care sunt similare în logică ar trebui să funcționeze diferit. Efectuarea mai multor metode de același tip pentru diferite tipuri (get_news, get_announcements, get_articles) este complet ignorantă. Aici este util polimorfismul.

Clasa abstracte

În linii mari, aceasta este o clasă șablon. Implementează funcționalitatea doar la nivelul la care este cunoscută în prezent. Clasele derivate îl completează. Dar, este timpul să trecem de la teorie la practică. Permiteți-mi să fac o rezervare imediat: luăm în considerare un exemplu primitiv cu funcționalitate minimă. Toate explicațiile sunt în comentariile din cod.

clasa abstractă Publicaţie
{
// tabel care stochează date despre element
protejat $table ;

// proprietățile elementului ne sunt necunoscute
protejat $properties = array();

// constructor

{
// rețineți că nu știm de la ce tabel avem nevoie pentru a obține datele
$rezultat = mysql_query ("SELECT * FROM `" . $this -> table . "` WHERE `id`="" . $id . "" LIMIT 1" );
// nici noi nu știm ce date am primit
$this -> properties = mysql_fetch_assoc ($rezultat);
}

// metoda, aceeași pentru orice tip de publicație, returnează valoarea proprietății
funcția publică get_property ($nume)
{
if (isset($this -> proprietăți [ $nume]))
returnează $this -> proprietăți [ $nume ];

Returnează false;
}

// metoda, aceeași pentru orice tip de publicație, stabilește valoarea proprietății
funcția publică set_property ($nume, $valoare)
{
if (!isset($this -> proprietăți [ $nume]))
return false;

$this -> proprietăți [ $nume ] = $valoare ;

Returnează valoarea $;
}

// și această metodă ar trebui să imprime publicația, dar nu știm exact cum să facem acest lucru și, prin urmare, o declarăm abstractă
funcție publică abstractă do_print();
}

Clase derivate

Acum puteți trece la crearea de clase derivate care implementează funcționalitatea lipsă.

Class News extinde Publicarea
{
// constructor al clasei de știri, derivat din clasa publicații
funcția publică __construct ($id)
{
// setează valoarea tabelului în care sunt stocate datele de știri
$this -> table = "news_table" ;
parent :: __construct ($id );
}

Funcția publică do_print()
{
echo $this -> proprietăți ["titlu"];
ecou"

" ;
echo $this -> proprietăți ["text" ];
ecou"
Sursa: " . $this -> proprietati [ "sursa" ];
}
}

Anunțul de clasă extinde Publicarea
{
// constructor al clasei de anunț derivat din clasa de publicare
funcția publică __construct ($id)
{
// setați valoarea tabelului în care sunt stocate datele publicitare
$this -> table = "tabel_anunțuri" ;
// apelează constructorul clasei părinte
parent :: __construct ($id );
}

// suprascrie metoda de tipărire abstractă
funcția publică do_print()
{
echo $this -> proprietăți ["titlu"];
ecou "
Atenţie! Anunțul este valabil până la „. $this -> proprietăți ["end_date" ];
ecou"

" . $this -> proprietăți [ "text" ];
}
}

Articolul de clasă extinde Publicarea
{
// constructor al clasei de articole, derivat din clasa de publicare
funcția publică __construct ($id)
{
// setează valoarea tabelului în care sunt stocate datele despre articole
$this -> table = "tabel_articole" ;
// apelează constructorul clasei părinte
parent :: __construct ($id );
}

// suprascrie metoda de tipărire abstractă
funcția publică do_print()
{
echo $this -> proprietăți ["titlu"];
ecou"

" ;
echo $this -> proprietăți ["text" ];
ecou"
" . $this -> proprietăți [ "autor" ];
}
}

Acum despre utilizare

Ideea este că același cod este folosit pentru obiecte din clase diferite.

// umple tabloul de publicare cu obiecte derivate din Publication
$publications = Noutăți noi ($news_id);
$publications = new Announcement($announcement_id);
$publications = articol nou($articol_id);

Foreach ($publications ca $publication) (
// dacă lucrăm cu moștenitorii Publicației
dacă ($publication instanceof Publication) (
// apoi tipăriți datele
$publicatie -> do_print();
) altfel (
// gestionarea excepțiilor sau erorilor
}
}

Asta e tot. Cu o ușoară mișcare a mâinii, pantalonii se transformă în pantaloni scurți eleganti :-).

Principalul beneficiu al polimorfismului este ușurința cu care pot fi create noi clase care se comportă similar cu cele înrudite, ceea ce permite, la rândul său, extensibilitatea și modificarea. Articolul arată doar un exemplu primitiv, dar chiar și acesta arată cum utilizarea abstracțiilor poate facilita dezvoltarea. Putem lucra cu știri la fel cum facem cu reclame sau articole și nici nu trebuie să știm cu ce lucrăm! În aplicații reale, mult mai complexe, acest beneficiu este și mai mare.

Puțină teorie

• Metodele care necesită suprascrie se numesc abstracte. Este logic ca, dacă o clasă conține cel puțin o metodă abstractă, atunci este și abstractă.
• Evident, un obiect dintr-o clasă abstractă nu poate fi creat, altfel nu ar fi abstract.
• O clasă derivată are proprietăți și metode care aparțin clasei de bază și poate avea, de asemenea, propriile sale metode și proprietăți.
• O metodă care este suprascrisă într-o clasă derivată se numește metodă virtuală. Nu există informații despre această metodă în clasa abstractă de bază.
• Scopul abstracției este de a defini o metodă în locul în care există cele mai complete informații despre cum ar trebui să funcționeze.

UPD:În ceea ce privește încălcările sql-inj și MVC - domnilor, acesta este doar un exemplu și un exemplu de polimorfism, în care nu consider că este necesar să acordăm atenție acestor lucruri. Acesta este un subiect pentru articole complet diferite.

Programarea este procesul de dezvoltare a soluțiilor pentru probleme „vii”, dinamice sub formă de structuri rigide de cod, date, funcții și algoritmi. Procedura de formare a sintaxei stricte din semantică vagă. Problemele din lumea reală sunt o mare problemă bine-cunoscută în algoritmizare: pentru a obține soluția dorită, problema trebuie plasată în structuri sintactice precise.

OOP a încercat de două ori să „sparge” acest concept străvechi de programare, dar „cătușele” stilului clasic de codificare a datelor și algoritmi sunt încă puternice.

Nivel și calificări

Informatica a inceput cu calcule, dar viteza cu care creste accelerarea miscarii in domeniul prelucrarii informatiilor nu este inca suficient de rapida pentru ca programarea clasica sa devina imposibila si sa inceteze sa existe.

De asemenea, este obiectiv ca dezvoltatorul să nu insiste, iar clientul să nu ceară o soluție reală la problemele reale. Ambele părți sunt obișnuite să fie limitate de instrumentele disponibile și de capabilitățile familiare.

Formele de polimorfism OOP, ideile de încapsulare a codului și moștenirea proprietăților (metodelor) se află în sfera programării, dar nu în sfera problemei care se rezolvă.

Un exemplu în acest sens este biblioteca PHPOffice/PHPWord. Pentru a-l folosi, aveți nevoie de calificările unui dezvoltator, trebuie să vă creați propriul sistem de obiecte, dar nivelul actual al clientului (cerințele clientului) este o compoziție banală pe care programatorul o acoperă cu propria sa dezvoltare (altfel cerințele nu pot fi satisfăcute ). Situatia este cam asa:

În acest caz, utilizarea unei biblioteci este sarcina formatării documentelor, de exemplu, o diplomă sau disertație trebuie formatată conform standardului. Clientul și-a prezentat cerințele, iar programatorul a mers pe drumul său mult mai departe.

A fost efectuată o analiză completă a documentului, asamblarea acestuia în formatul necesar, lucrul cu tabele de orice nivel de imbricare, îmbinarea și împărțirea celulelor, imprimarea în orice direcție etc.

Polimorfismul și OOP

Nu mă pot gândi la o definiție mai bună a polimorfismului decât să mă refer la istoria dezvoltării ideii de programare orientată pe obiecte, atât de populară astăzi, atât de des folosită, dar nerealizateîn esență încă este.

• încapsulare;
• polimorfism;
• moştenire.

Unii mai adaugă: abstracția, iar cel mai adesea acest lucru, și într-adevăr punctul principal, este folosit ca fundație pentru descrierea esenței OOP.

Deci, opiniile despre POO sunt polimorfe: descriu un lucru, sunt proiectate diferit sau, dimpotrivă, descriu lucruri diferite, dar se bazează pe patru poziții identice.

Principiul democratic nu este caracteristic domeniului tehnologiei informației, dar ar trebui să i se acorde cuvenția: combinarea și coexistența multor opinii despre același lucru este un adevărat polimorfism în acțiune.

Definiții populare ale polimorfismului

OOP este următoarea etapă în dezvoltarea tehnologiei informației. Puțini oameni argumentează acest lucru, dar principalele sale axiome și prevederi diferă atât de mult în ceea ce privește semantica, încât nu merită atenție în afara totalității lor.

1. Polimorfismul în programare este capacitatea de a oferi aceeași interfață pentru diferite forme de bază (tipuri de date).
2. Polimorfismul este capacitatea obiectelor de a avea implementări diferite.
3. Polimorfismul este capacitatea unei funcții...
4. Clasic (de la creatorul C/C++): „o interfață - multe implementări”.
5. Polimorfismul parametric înseamnă...
6. Polimorfismul este o prevedere a teoriei tipurilor...
7. Abstracția este imposibilă fără încapsulare și moștenire, la fel cum polimorfismul este imposibil fără moștenire...

Putem fi de acord că toate acestea se referă la același lucru: dar forma de exprimare a gândirii, esența și conținutul nu sunt similare. Dar mai există ceva în comun.

Entitate: dezvoltator - client

Dezvoltarea clasică a programelor presupune prezența unui programator și a unei sarcini (client, client). Un programator examinează o problemă, o formalizează și realizează cod care duce la o soluție. Clientul neagă tot ceea ce este propus sau doar o parte din el, subliniind neajunsuri, iar programatorul își face treaba din nou.

Acest ciclu al procesului de rezolvare a problemelor sugerează că două entități complet diferite sunt combinate în mod clar aici:

• computerul nu poate rezolva problema în sine;
• este nevoie de un program pentru ca computerul să poată „înțelege” și „rezolva” problema.

Sarcina este sfera de competență a clientului, programul este un algoritm pentru „adaptarea” sarcinii la capacitățile computerului - sfera de competență a programatorului. Rolul acestuia din urmă este de a „adapta” computerul la cerințele sarcinii, iar acest lucru este inutil!

promoții abstract. Există obiecte - aceasta este sfera clientului; există implementarea obiectelor - aceasta este sfera programatorului. Nu există nicio legătură „tehnologică” între client și dezvoltator. Ideea este radicală, nu a fost implementată până astăzi, dar ceva funcționează deja stabil.

Ferestre, butoane și alte obiecte

Istoria Air Art Technology, Object Magazine, Turbo Vision, Graph Vision este deja istorie. Puțini oameni își amintesc aceste implementări ale OOP, ele sunt practic neutilizate și uitate, dar interfața ferestrei Windows este familiară milioanelor de utilizatori, iar obiectele din PHP, JavaScript și alte limbaje ale tehnologiei Internet sunt folosite de sute de mii de dezvoltatori de coduri, și milioane de vizitatori ai resurselor web știu despre ele.

Acesta este probabil singurul mod corect în care ar fi trebuit să se dezvolte OOP: încapsulare, moștenire, polimorfism pentru dezvoltator, dar nu pentru utilizator. Este caracteristic faptul că această poziție a fost cea principală în dezvoltarea designului vizual (interfeței) a software-ului Windows și a programelor de aplicație precum Turbo Vision și Graph Vision.

Conceptul din spatele produselor precum Air Art Technology și Object Magazine a fost semnificativ diferit. Aici, obiectul abstract a fost primul strămoș al structurii informaționale, încapsulând codul de procesare a informațiilor la nivel abstract. Obiectele ferestrelor, butoanelor și elementelor de design vizual au fost secundare aici.

În prima versiune (Windows & etc.), paradigma OOP: încapsulare, moștenire, polimorfism a fost desemnată la nivelul unui strămoș abstract, iar implementarea codului s-a format la nivelul fiecărui descendent specific de-a lungul ramurii de moștenire conform la structura și conținutul cerut.

În a doua opțiune (Revista Air Art Technology and Object), nivelul obiectului abstract este important. Ceea ce va avea un anumit descendent nu este ideea, principalul lucru este că ramura sa moștenitoare satisface cerințele tuturor părinților până la abstracția rădăcină.

Obiect şi sistem de obiecte: algoritm

Un concept ideal orientat pe obiecte poate manipula doar obiecte și sisteme de obiecte.

În limbajele de programare moderne, un obiect (clasă) este de obicei înțeles ca o descriere a unui obiect și o instanță a unui obiect, iar pentru a utiliza descrierea unui obiect, limbajele permit programatorului să lucreze cu obiecte statice, în timp ce un obiect dinamic - descrieri, cu conținut și structură unică, dar folosind aceleași metode (proprietăți) de descriere.

Practica curentă raportează conceptul de obiect la un instrument, adică la un limbaj de programare, interfață, acces la baze de date, conexiune la rețea, dar nu există nimic care să indice interesele clientului, problema fiind rezolvată.

Acest lucru este ideal pentru OOP simplu: polimorfismul face posibilă realizarea, în special, a unei varietăți de elemente de design, dar gestionarea acestora cu același cod. Dar aici nu vorbim despre obiectele problemei, care nu este deloc considerată ca subiect de analiză orientată pe obiecte.

Programatorii au adoptat OOP ca mijloc de a îmbunătăți calitatea și productivitatea muncii lor, dar nu au cedat un singur fragment din „teritoriul lor” clientului. Conceptele de bază ale OOP - încapsulare, moștenire, polimorfism - au rămas în zona de dezvoltare și nu au fost transplantate în zona de activitate.

Obiectul și sistemul de obiecte: problemă și soluție

Calculator - programator - sarcină. Veriga din mijloc este redundantă. În mod ideal, ar trebui să existe doar două circuite, relativ dependente: (calculator - programator) - sarcină. Adică utilizatorul, clientul sau vizitatorul are un instrument pentru a-și rezolva problema. Clientului nu îi pasă cum este implementat instrumentul.

În mod ideal, acesta este doar un computer care este capabil să înțeleagă ce vrea clientul și să facă ceea ce dorește. Cum va arăta: un program local sau un site web accesibil printr-un browser, un program special pentru procesarea informațiilor distribuite, un sistem de informații pentru client - nu contează.

Este important să nu existe o legătură inutilă între sarcină și computer, dar primul este înțeles și rezolvat de al doilea. Pentru a atinge acest scop, computerul și clientul trebuie să fie conectați printr-un singur sistem de obiecte, iar semnificația, structura și conținutul fiecărui obiect sunt determinate de client, iar metodele și proprietățile obiectelor sunt implementate de programator.

Este ideal atunci când munca clientului privind crearea sistemului de obiecte de care are nevoie și munca de implementare a metodelor și proprietăților acestor obiecte sunt separate în timp. Cu cât implementarea unui sistem de obiecte (programator) este mai departe de conținutul său semantic (client), cu atât calitatea procesului este mai bună.

Nimic nu împiedică clientul și programatorul să interacționeze în procesul de rezolvare a unei probleme, dar o separare clară a semanticii este importantă. Fiecare ar trebui să se ocupe de propria afacere, programatorul nu este obligat să stăpânească domeniul de aplicare al sarcinii, iar clientul nu ar trebui să înțeleagă codul și, în plus, părțile nu ar trebui să-și dea reciproc sfaturi despre ceea ce nu le privește.

Programare tradițională și de obiecte

Postulatele de bază ale OOP: încapsularea, moștenirea, polimorfismul în forma în care au devenit familiare și solicitate, duc la o îmbunătățire vizibilă a calității și fiabilității codului, accelerează semnificativ munca programatorului și au multe a altor calități pozitive.

Dar lucrurile sunt încă acolo: programarea clasică nu este inferioară pozițiilor sale și multe idei orientate pe obiecte sunt implementate în codul clasic.

Totuși, ideile de POO și recursivitate au condus la o influență adecvată asupra sintaxei operatorilor de sintaxă clasică, asupra logicii construirii codului obișnuit care nu are nimic de-a face cu stilul de scriere și gândire orientat pe obiect.

Listele și cozile au fost transformate, a apărut conceptul primului și ultimului element al unui tablou, au apărut buclele „pentru fiecare”, iar opțiunile de referință pentru denumire, utilizare și execuție au devenit și mai populare decât înainte.

De fapt, însuși faptul că variabilele și-au pierdut fața „clară” (tipul unei variabile se poate schimba după cum este necesar și nu este deloc nevoie de a descrie o variabilă) spune că clasicii, de fapt, cu mult timp în urmă au devenit obiect- a orientat și a recunoscut principiile de bază ale POO: încapsularea, moștenirea, polimorfismul ca idei de importanță semnificativă.

Pe ce se bazează: un obiect sau un sistem?

Abstracția, ca principală poziție conceptuală a OOP, indiferent de locul în care se află aria de responsabilitate (implementare) a obiectului - la nivelul primului obiect abstract sau la nivelul unui anumit descendent - lasă deschisă întrebarea: de unde să încep totul, de la obiect sau de la sistem?

Dacă puneți un obiect ca bază, atunci nu va deveni niciodată un sistem, deoarece sistemul va fi în interiorul lui și el însuși va deveni o imagine rigidă a unui început foarte specific. Aici apar probleme cu abstracția: obiectul inițial surprinde exact principalul în problema care se rezolvă, adică nu mai este transferabil la o altă problemă.

Dacă ne bazăm pe un sistem de obiecte, obținem un sistem de sisteme. Acest lucru este greu de imaginat în legătură cu o anumită sarcină și de unde să începem dezvoltarea este, de asemenea, greu de înțeles. În general, polimorfismul OOP cu diferențele sale în entități, forme de implementare și numărul de parametri reali în funcții oferă o idee despre sistemul care se află la început ca:

• despre opțiunile de rezolvare a unei probleme (de exemplu, un meniu);
• despre condițiile inițiale (aplicarea problemei în diferite condiții, date);
• despre modurile de operare (testare, setare, operare).

Dar acesta și altele similare nu oferă niciun motiv pentru a baza soluția problemei pe un sistem de obiecte. Adesea este suficient să definiți un singur obiect de pornire.

Istoricul procesului de rezolvare a problemelor

Cele mai importante principii ale POO: polimorfismul și abstractizarea - prioritizează obiectul inițial ca sistem de obiecte. Într-o dezbatere despre care ar trebui să vină primul, puiul sau oul, aici câștigă puiul.

Nu există nicio îndoială că totul trebuie să înceapă cu un obiect abstract, și nu cu un sistem de obiecte. Dar dacă luăm în considerare factorul timp și îl aplicăm la nivelul fiecărui obiect, începând de la primul abstract, atunci ideea contradictorie de a pune atât obiectul, cât și sistemul la începutul deciziei este numai unul rezonabil.

Dacă conceptul clasic de programare, în cursul rezolvării unei probleme, modifică datele, conținutul bazei de date, modifică fișierele etc., atunci în conceptul de POO, polimorfismul, încapsularea și factorul de timp modifică conținutul, structura și proprietăţile sistemului de obiecte ale problemei care se rezolvă.

Un programator în OOP este cel mai puțin interesat de conceptul de fișier, bază de date, algoritm - acestea sunt detalii; aici programatorul gândește în obiecte, dar obiectele există în timp și se schimbă în cursul realizării dorite.

Astfel, la început se află obiectul ca sistem de obiecte și logica acestui sistem - scara de timp: lansarea unei sarcini, formarea primului obiect, introducerea sau colectarea datelor, formarea următorului obiect, dar nimic nu împiedică primul obiect trecând la următoarea soluție.

Fiecare nivel de obiecte acționează ca un sistem independent de obiecte, adică este un singur obiect, dar în contextul procesului care a început și al sensului timpului, este un sistem de obiecte pe scara timpului. Pentru o implementare completă a OOP, polimorfismul, moștenirea și factorul timp asigură împreună dinamica primului, adică un obiect nu poate doar să se schimbe în timp, ci și să genereze obiecte neintenționate de dezvoltator, generate de execuția unui sarcină în timpul procesului, concepută de client.

Polimorfism OOP real, de exemplu

Complexitatea problemelor pe care le poate face OOP nu este comparabilă cu ceea ce este posibil cu versiunea clasică a programelor de scriere. Desigur, este întotdeauna posibil să se rezolve orice problemă în mod obișnuit, dar întrebarea cât de mult va „costa” timp și efort face adesea ca rezultatul să fie inutil.

Biblioteca PHPOffice/PHPWord a fost dezvoltată nu cu mult timp în urmă, dar pentru a-și folosi capacitățile, aproape întotdeauna trebuie să vă creați propriul sistem de obiecte. De exemplu, un simplu fișier *.docx:

este o arhivă zip cu multe fișiere și foldere în format Office Open XML (OpenXML, OOXML). Fiecare fișier este scris în etichete XML, iar atunci când adăugați, schimbați și ștergeți litere, cuvinte, tabele, liste și alte elemente, conținutul fișierelor începe să reprezinte o secvență de etichete care nu conțin întotdeauna elemente complete; adesea un element este scris cu multe etichete.

Dacă vă imaginați acest fișier ca o secvență de etichete, obțineți o imagine interesantă:

Este ușor de observat că primul și singurul paragraf al documentului este reprezentat de multe etichete. În ceea ce privește tabelul și tabelele încorporate în acesta, volumul descrierii tuturor elementelor nu poate fi perceput, dar este accesibil unei aplicații orientate pe obiecte.

De fapt, în figură, verde este rezultatul de testare a etichetelor, galbenul este parametrii și tipul etichetei, iar bejul este conținutul. Obiectele create sunt orientate către prelucrarea automată. Doar operațiunile de deschidere a unui fișier document, formatare și scriere a acestuia devin disponibile unei persoane.

Soluția este simplă și practică, dar implementarea este mai mult orientată către computer decât pe om datorită volumului de funcționalități realizate și a relațiilor complexe dintre obiecte.

Statul zonei OOP

Dezvoltarea sistemelor de gestionare a site-urilor web, tehnologiilor pentru configurarea și gestionarea serverelor și experiența în dezvoltarea de site-uri web dinamice au făcut ca programarea orientată pe obiecte să fie accesibilă tuturor. Problema este cum să vă schimbați gândirea și să vă obișnuiți cu gândirea la nivel de obiecte, și nu în contextul codului executat secvenţial.

De obicei, trecerea de la programarea clasică la programarea orientată pe obiecte durează două până la trei luni, dar costurile merită mai mult decât. Potențialul limbajelor de programare moderne, în primul rând PHP și JavaScript, va satisface cel mai sofisticat dezvoltator.

OOP modern - polimorfismul, moștenirea și capacitatea de a forma proprietăți ale obiectului - sunt convenabile și practice, sintaxa limbajului și instrumentele auxiliare asigură ușurința în utilizare și eficiența codului.

Perspective asupra ideii de obiect

Este destul de dificil de spus cât va dura programarea clasică și cum se va dezvolta OOP. Aparent, dezvoltatorii de instrumente nu intenționează să ia în considerare contextul consumatorului (utilizator, client).

Instrumentele OOP - polimorfism, moștenire, încapsulare și abstractizare - sunt orientate către dezvoltatori.

Sistemele informatice moderne și resursele web se străduiesc să reflecte realitatea, să asigure funcționarea obiectelor reale și să creeze un mediu de funcționare a acestora atât de simplu încât să fie accesibil unui consumator care este departe de a programa și complet cufundat în zona lor de activitate. competență.