Il polimorfismo genetico è una condizione in cui esiste una diversità di geni a lungo termine, ma la frequenza del gene più raro nella popolazione è superiore all'1%. Il suo mantenimento avviene a causa della costante mutazione dei geni, nonché della loro costante ricombinazione. Secondo la ricerca condotta dagli scienziati, il polimorfismo genetico è diventato molto diffuso, perché possono esserci diversi milioni di combinazioni genetiche.

Grande magazzino

Un migliore adattamento di una popolazione a un nuovo ambiente dipende da una grande quantità di polimorfismo, e in questo caso l'evoluzione avviene molto più velocemente. Non è pratico stimare l’intero numero di alleli polimorfici utilizzando metodi genetici tradizionali. Ciò è dovuto al fatto che la presenza di un determinato gene nel genotipo si ottiene incrociando individui che hanno caratteristiche fenotipiche diverse determinate dal gene. Se si sa quale parte di una determinata popolazione è composta da individui con fenotipi diversi, diventa possibile determinare il numero di alleli da cui dipende la formazione di un particolare tratto.

Come tutto cominciò?

La genetica iniziò a svilupparsi rapidamente negli anni '60 del secolo scorso, fu allora che iniziarono ad essere utilizzati gli enzimi nei gel, che permisero di determinare il polimorfismo genetico. Cos'è questo metodo? È con il suo aiuto che le proteine ​​si muovono in un campo elettrico, che dipende dalla dimensione della proteina spostata, dalla sua configurazione e dalla carica totale nelle diverse parti del gel. Successivamente, a seconda della posizione e del numero di macchie che compaiono, viene identificata la sostanza identificata. Per valutare il polimorfismo proteico in una popolazione, vale la pena esaminare circa 20 o più loci. Quindi, utilizzando un metodo matematico, vengono determinati il ​​numero e il rapporto tra omo ed eterozigoti. Secondo la ricerca, alcuni geni possono essere monomorfici, mentre altri possono essere insolitamente polimorfici.

Tipi di polimorfismo

Il concetto di polimorfismo è estremamente ampio; comprende una variante transitoria e una equilibrata. Ciò dipende dal valore selettivo del gene e dalla selezione naturale, che esercita pressione sulla popolazione. Inoltre, può essere genetico e cromosomico.

Polimorfismo genico e cromosomico

Il polimorfismo genetico è rappresentato nel corpo da più di un allele; un esempio lampante di ciò è il sangue. Cromosomico rappresenta le differenze all'interno dei cromosomi che si verificano a causa di aberrazioni. Allo stesso tempo, ci sono differenze nelle regioni eterocromatiche. In assenza di patologie che portino a menomazione o morte, tali mutazioni sono neutre.

Polimorfismo transizionale

Il polimorfismo di transizione si verifica quando un allele che una volta era comune viene sostituito in una popolazione da un altro che fornisce al suo portatore una maggiore adattabilità (chiamato anche allelismo multiplo). Con una data varietà, c'è uno spostamento direzionale nella percentuale di genotipi, a causa della quale si verifica l'evoluzione e si svolgono le sue dinamiche. Il fenomeno del meccanismo industriale può essere un buon esempio che caratterizza il polimorfismo transizionale. Ciò che è lo dimostra una semplice farfalla che, con lo sviluppo dell'industria, ha cambiato il colore bianco delle sue ali in scuro. Questo fenomeno cominciò ad essere osservato in Inghilterra, dove più di 80 specie di farfalle passarono dai fiori crema pallido a quelli scuri, che fu notato per la prima volta dopo il 1848 a Manchester a causa del rapido sviluppo dell'industria. Già nel 1895 più del 95% delle falene acquisiva una colorazione scura delle ali. Tali cambiamenti sono associati al fatto che i tronchi degli alberi sono diventati più fumosi e le farfalle di colore chiaro sono diventate facili prede di tordi e pettirossi. I cambiamenti si sono verificati a causa di alleli melanici mutanti.

Polimorfismo bilanciato

La definizione di "polimorfismo bilanciato" caratterizza l'assenza di uno spostamento nei rapporti numerici di varie forme di genotipi in una popolazione che si trova in condizioni ambientali stabili. Ciò significa che di generazione in generazione il rapporto rimane lo stesso, ma può oscillare leggermente entro un certo valore, che è costante. In confronto al polimorfismo transitorio ed equilibrato: che cos'è? È principalmente un processo evolutivo statico. I. I. Shmalhausen nel 1940 gli diede anche il nome di eteromorfismo di equilibrio.

Esempio di polimorfismo bilanciato

Un chiaro esempio di polimorfismo equilibrato è la presenza di due sessi in molti animali monogami. Ciò è dovuto al fatto che hanno uguali vantaggi selettivi. Il loro rapporto all'interno di una popolazione è sempre uguale. Se in una popolazione esiste la poligamia, il rapporto selettivo tra rappresentanti di entrambi i sessi può essere interrotto, nel qual caso i rappresentanti di un sesso possono essere completamente distrutti o eliminati dalla riproduzione in misura maggiore rispetto ai rappresentanti del sesso opposto.

Un altro esempio potrebbe essere il gruppo sanguigno secondo il sistema ABO. In questo caso, la frequenza di diversi genotipi in diverse popolazioni può essere diversa, ma allo stesso tempo non cambia la sua costanza di generazione in generazione. In poche parole, nessun genotipo ha un vantaggio selettivo rispetto ad un altro. Secondo le statistiche, gli uomini con il primo gruppo sanguigno hanno un'aspettativa di vita più lunga rispetto ad altri membri del sesso più forte con altri gruppi sanguigni. Insieme a ciò, il rischio di sviluppare un'ulcera duodenale in presenza del primo gruppo è maggiore, ma questa può perforarsi e ciò causerà la morte se l'assistenza viene ritardata.

Equilibrio genetico

Questo stato fragile può essere sconvolto in una popolazione come conseguenza del verificarsi, e devono verificarsi con una certa frequenza e in ogni generazione. Gli studi hanno dimostrato che i polimorfismi dei geni del sistema emostatico, la cui decodificazione chiarisce se il processo evolutivo promuove questi cambiamenti o, al contrario, li contrasta, sono estremamente importanti. Se segui il corso del processo mutante in una particolare popolazione, puoi anche giudicarne il valore per l'adattamento. Può essere uguale a uno se la mutazione non viene esclusa durante il processo di selezione e non esistono ostacoli alla sua diffusione.

La maggior parte dei casi mostra che il valore di tali geni è inferiore a uno e, nel caso in cui tali mutanti non siano in grado di riprodursi, tutto si riduce a 0. Mutazioni di questo tipo vengono spazzate via nel processo di selezione naturale, ma ciò non avviene. Non si escludono cambiamenti ripetuti nello stesso gene, che compensano l'eliminazione effettuata per selezione. Quindi viene raggiunto l'equilibrio, i geni mutati possono apparire o, al contrario, scomparire. Ciò porta ad un processo equilibrato.

Un esempio che può caratterizzare chiaramente ciò che sta accadendo è l'anemia falciforme. In questo caso, un gene mutato dominante in uno stato omozigote contribuisce alla morte prematura dell'organismo. Gli organismi eterozigoti sopravvivono ma sono più suscettibili alla malattia malarica. Nelle aree di distribuzione di questa malattia tropicale è possibile rintracciare il polimorfismo bilanciato del gene dell'anemia falciforme. In una tale popolazione, gli omozigoti (individui con gli stessi geni) vengono eliminati e la selezione agisce a favore degli eterozigoti (individui con geni diversi). A causa della selezione multivettoriale che avviene nel pool genetico della popolazione, in ogni generazione vengono mantenuti i genotipi, che garantiscono una migliore adattabilità dell'organismo alle condizioni ambientali. Insieme alla presenza del gene dell'anemia falciforme, esistono altri tipi di geni che caratterizzano il polimorfismo. Cosa dà questo? La risposta a questa domanda sarà un fenomeno chiamato eterosi.

Mutazioni eterozigoti e polimorfismo

Il polimorfismo eterozigote prevede l'assenza di cambiamenti fenotipici in presenza di mutazioni recessive, anche se dannose. Ma allo stesso tempo, possono accumularsi nella popolazione a un livello elevato, che può superare le mutazioni dominanti dannose.

processo evolutivo

Il processo evolutivo è continuo e il suo prerequisito è il polimorfismo. Ciò significa la costante adattabilità di una particolare popolazione al suo habitat. Gli organismi di sesso diverso che vivono all'interno di uno stesso gruppo possono trovarsi in uno stato eterozigote e trasmessi di generazione in generazione per molti anni. Allo stesso tempo, la loro manifestazione fenotipica potrebbe non esistere, a causa dell'enorme riserva di variabilità genetica.

Gene del fibrinogeno

Nella maggior parte dei casi, i ricercatori considerano il polimorfismo del gene del fibrinogeno come un precursore dello sviluppo dell'ictus ischemico. Ma al momento sta emergendo il problema in cui i fattori genetici e acquisiti sono in grado di influenzare lo sviluppo di questa malattia. Questo tipo di ictus si sviluppa a causa della trombosi delle arterie cerebrali e, studiando il polimorfismo del gene del fibrinogeno, si possono comprendere molti processi, influenzando i quali si può prevenire la malattia. Al momento, gli scienziati non hanno studiato a sufficienza le connessioni tra cambiamenti genetici e parametri biochimici del sangue. Ulteriori ricerche consentiranno di influenzare il decorso della malattia, modificarne il decorso o semplicemente prevenirla in una fase iniziale di sviluppo.

Programmazione orientata agli oggetti(OOP) è un approccio alla creazione di programmi basato sull'uso di classi e oggetti che interagiscono tra loro.

Una classe (classe Java) descrive la struttura e il comportamento degli oggetti. Un dispositivo viene descritto attraverso un insieme di caratteristiche (proprietà) e il comportamento viene descritto attraverso un insieme di operazioni (metodi) disponibili per gli oggetti. Le classi possono essere create in base a quelle esistenti aggiungendo o sovrascrivendo proprietà e metodi.

Le classi rappresentano i modelli in base ai quali vengono creati gli oggetti. Gli oggetti sono elementi di programma che hanno un insieme di caratteristiche e comportamenti simili (cioè sono elementi costruiti sulla base della stessa classe). Ogni oggetto ha un certo stato, è determinato dal valore di tutte le sue proprietà. In un programma possono esistere più classi e oggetti di classi diverse possono interagire tra loro (tramite metodi).

L'eredità si estende

L'ereditarietà è parte integrante di Java. Quando si utilizza l'ereditarietà, si tiene conto del fatto che una nuova classe che eredita le proprietà della classe base (genitore) ha tutte le proprietà della classe genitore. Il codice utilizza l'operando si estende, seguito dal nome della classe base. Ciò apre l'accesso a tutti i campi e metodi della classe base.

Utilizzando l'ereditarietà è possibile creare una generica "classe Java" che definisce caratteristiche comuni ad un insieme di elementi correlati. Quindi puoi ereditare da esso e creare classi aggiuntive per le quali puoi definire caratteristiche aggiuntive uniche per loro.

La principale classe ereditata in Java è chiamata superclasse super. Viene chiamata la classe ereditaria sottoclasse. Pertanto, una sottoclasse è una versione specializzata di una superclasse che eredita tutte le proprietà della superclasse e aggiunge i propri elementi unici.

Consideriamo un esempio di descrizione della classe Java "uno studente Studente, che ha nome, cognome, età e numero di gruppo. Creeremo una classe studente basata sulla super classe dell'utente Utente, che ha già un nome, cognome ed età definiti:

Utente della classe pubblica ( int age; String firstName; String lastName; // Costruttore public User(int age, String firstName, String lastName) ( this.age = age; this.firstName = firstName; this.lastName = lastName; ) )

Ora creiamo una classe separata Student, che eredita le proprietà della super classe. Quando si eredita una classe, è necessario anche sovrascrivere i costruttori della classe genitore:

Classe pubblica Student estende Utente ( int group; // Costruttore public Student(int age, String firstName, String lastName) ( super(age, firstName, lastName); ) boolean isMyGroup(int g) ( return g == group; ) )

Parola chiave si estende mostra che stiamo ereditando dalla classe User.

Parola chiave eccellente

Nel costruttore della classe Student, chiamiamo il costruttore della classe genitore tramite l'operatore super, passandogli l'intero set di parametri necessari. In Java la parola chiave super denota una superclasse, cioè La classe da cui deriva la classe corrente. La parola chiave super può essere utilizzata per chiamare un costruttore di superclasse e per accedere a un membro della superclasse nascosto da un membro della sottoclasse.

Vediamo come succede eredità in termini di creazione di oggetti:

Studente studente = nuovo Studente(18, "Kisa", "Vorobyaninov", 221);

Per prima cosa viene aperto il costruttore della classe Student, quindi viene chiamato il costruttore della superclasse User e quindi vengono eseguite le restanti operazioni nel costruttore Student. Questa sequenza di azioni è abbastanza logica e consente di creare oggetti più complessi basati su oggetti più semplici.

Una superclasse può avere più versioni sovraccaricate dei suoi costruttori, quindi il metodo super() può essere chiamato con parametri diversi. Il programma eseguirà il costruttore che corrisponde agli argomenti specificati.

Seconda forma di parola chiave super funziona come una parola chiave Questo, solo che in questo caso ci riferiamo sempre alla superclasse della sottoclasse in cui viene utilizzata. La forma generale è la seguente:

Qui il membro può essere un metodo o una variabile di istanza. Questa forma è adatta nei casi in cui i nomi dei membri di una sottoclasse nascondono i membri di una superclasse con gli stessi nomi.

Classe A ( int i; ) // eredita dalla classe A classe B estende A ( int i; // il nome della variabile corrisponde e nasconde la variabile i nella classe A B(int a, int b) ( super.i = a; // accede alla variabile i dalla classe A i = b; // accedo alla variabile i dalla classe B ) void show() ( System.out.println("i dalla superclasse è " + super.i); System.out.println(" i nella sottoclasse è " + i); ) ) class MainActivity ( B subClass = new B(1, 2); subClass.show(); )

Di conseguenza, dovremmo vedere nella console:

I della superclasse è 1 i nella sottoclasse è 2

Metodo override, Override

Se in una gerarchia di classi il nome e la firma del tipo di un metodo della sottoclasse corrispondono agli attributi di un metodo della superclasse, il metodo della sottoclasse sovrascrive il metodo della superclasse. Quando un metodo sottoposto a override viene chiamato dalla sua sottoclasse, farà sempre riferimento alla versione di quel metodo della sottoclasse. E la versione della superclasse del metodo verrà nascosta.

Se è necessario accedere a una versione di un metodo sovrascritto definito in una superclasse, è necessario utilizzare la parola chiave super.

Non confondere l'override con il sovraccarico. L'override del metodo si verifica solo se i nomi e le firme del tipo dei due metodi sono identici. Altrimenti i due metodi risultano semplicemente sovraccarichi.

L'annotazione è apparsa in Java SE5 @Oltrepassare;. Se è necessario sovrascrivere un metodo, utilizzare @Override e il compilatore genererà un errore se lo si sovraccarica accidentalmente invece di sovrascriverlo.

In Java puoi ereditare solo da una classe.

Incapsulamento

In informatica, l'incapsulamento (latino: en capsula) è l'imballaggio di dati e/o funzioni in un singolo oggetto.

La base dell'incapsulamento in Java è la classe. Incapsulamento significa che i campi di un oggetto non sono direttamente accessibili ai suoi client: sono nascosti all'accesso diretto dall'esterno. L'incapsulamento protegge i dati di un oggetto da accessi indesiderati consentendo all'oggetto di controllare l'accesso ai propri dati.

Modificatori di accesso

Quando si descrive una classe, vengono utilizzati i modificatori di accesso. Modificatori di accesso può essere visto dalla prospettiva incapsulamento così e eredità. Se visti dal punto di vista dell'incapsulamento, i modificatori di accesso consentono di limitare l'accesso indesiderato ai membri della classe dall'esterno.

I membri pubblici di una classe costituiscono funzionalità esterne disponibili per altre classi. I membri indipendenti dalle funzionalità esterne vengono generalmente dichiarati privati, così come i metodi ausiliari che sono solo dettagli di implementazione e non sono di natura universale. Nascondendo l'implementazione di una classe, puoi modificare la logica interna di una classe separata senza modificare il codice degli altri componenti del sistema.

È consigliabile utilizzare l'accesso alle proprietà della classe solo attraverso i suoi metodi (il principio fagiolo classi, "POJO"), che consente di convalidare i valori dei campi, poiché l'accesso diretto alle proprietà è estremamente difficile da tracciare, il che significa che potrebbero essere assegnati valori errati in fase di esecuzione del programma. Questo principio si riferisce alla gestione dei dati incapsulati e consente di modificare rapidamente il modo in cui i dati vengono archiviati. Se i dati non vengono archiviati in memoria, ma in file o in un database, sarà necessario modificare solo alcuni metodi di una classe, anziché introdurre questa funzionalità in tutte le parti del sistema.

Il codice del programma scritto utilizzando il principio dell'incapsulamento è più semplice da eseguire il debug. Per sapere in quale momento e chi ha modificato la proprietà dell'oggetto che ci interessa, è sufficiente aggiungere l'output delle informazioni di debug al metodo dell'oggetto attraverso il quale si accede alla proprietà di questo oggetto. Quando si utilizza l'accesso diretto alle proprietà dell'oggetto, il programmatore dovrebbe aggiungere l'output delle informazioni di debug a tutte le sezioni del codice in cui viene utilizzato l'oggetto di interesse.

Esempio di una semplice descrizione del robot

Public class Robot ( private double x = 0; // Coordinata X corrente private double y = 0; // Coordinata Y corrente private double course = 0; // Rotta corrente (in gradi) 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; ) // Determinazione del corso public void setCourse(double course) ( this.course = course; ) // Spostamento verso una distanza public void forward(int distance) ( // Accesso al campo oggetto X x = x + distance * Math.cos ( course / 180 * Math.PI); // Accesso al campo oggetto Y y = y + distanza * Math.sin(course / 180 * Math.PI); ) // Stampa le coordinate del robot public void printCoordinates() ( System .out .println(x + "," + y); ) )

L'esempio di robot presentato utilizza una serie di metodi che iniziano con impostato E Ottenere. Questa coppia di metodi è spesso chiamata setter/getter. Questi metodi vengono utilizzati per accedere ai campi di un oggetto. I nomi dei metodi terminano con il nome del campo che inizia con una lettera MAIUSCOLO.

Nei metodi impostato passiamo il valore attraverso un parametro formale nella procedura. Nel codice della procedura, assegniamo un valore a una variabile oggetto/classe utilizzando la parola chiave Questo.

Questo.corso = corso...

Utilizzo delle parole chiave Questo necessario, perché il nome del parametro formale coincide con il nome della variabile oggetto. Se i nomi fossero diversi, sarebbe possibile Questo non usare.

Polimorfismo

Il polimorfismo è uno dei concetti fondamentali nella programmazione orientata agli oggetti, insieme all'ereditarietà e all'incapsulamento. La parola polimorfismo è di origine greca e significa “che ha molte forme”. Per capire cosa significa polimorfismo in relazione alla programmazione orientata agli oggetti, considera un esempio di creazione di un editor di grafica vettoriale in cui è necessario utilizzare un numero di classi sotto forma di un insieme di primitive grafiche: Piazza, Linea, Cerchio, Triangolo, eccetera. Ognuna di queste classi deve avere un metodo definito disegno per visualizzare sullo schermo la primitiva corrispondente.

Ovviamente, dovrai scrivere del codice che, per visualizzare l'immagine, itererà in sequenza tutte le primitive che devono essere visualizzate sullo schermo e chiamerà il metodo draw su ciascuna di esse.

Una persona che non ha familiarità con il polimorfismo molto probabilmente creerà diversi array: un array separato per ciascun tipo primitivo e scriverà il codice che scorre gli elementi di ciascun array in sequenza e chiama il metodo draw su ciascun elemento. Il risultato sarà approssimativamente il seguente codice:

// Definizione di array di primitive grafiche Square s = new Square ; Linea l = nuova linea; Cerchio c = nuovo Cerchio; Triangolo t = nuovo Triangolo; // Riempi tutti gli array con gli oggetti appropriati. . . // Ripete l'iterazione su tutte le celle dell'array. for (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(); }

Lo svantaggio del codice scritto sopra è la duplicazione di codice quasi identico per visualizzare ogni tipo di primitiva. È anche scomodo che con l'ulteriore modernizzazione del nostro editor grafico e l'aggiunta della possibilità di disegnare nuovi tipi di primitive grafiche, ad esempio Testo, Stella, ecc., con questo approccio dovremo modificare il codice esistente e aggiungere definizioni di nuovi array ad esso, nonché l'elaborazione degli elementi in essi contenuti.

Usando il polimorfismo, puoi semplificare notevolmente l'implementazione di tale funzionalità. Prima di tutto, creiamo una classe genitore Shape comune per tutte le nostre classi.

Classe pubblica Shape ( public void draw() ( System.out.println("Stub"); ) )

Successivamente creiamo varie classi discendenti: Quadrato, Linea, Cerchio e Triangolo:

La classe pubblica Point estende la forma ( public void draw() ( System.out.println("Square"); ) ) la classe pubblica Line estende la forma ( public void draw() ( System.out.println("Line"); ) ) public class Circle estende la forma ( public void draw() ( System.out.println("Circle"); ) ) public class Triangle estende la forma ( public void draw() ( System.out.println("Triangle"); ) )

Nei discendenti abbiamo sovrascritto il metodo draw. Di conseguenza, abbiamo ottenuto una gerarchia di classi, mostrata in figura.

Ora diamo un'occhiata alla straordinaria caratteristica del polimorfismo:

// Definizione e inizializzazione dell'array Shape a = new Shape (new Shape(), new Triangle(), new Square(), new Circle()); // Ciclo attraverso gli elementi dell'array for(int i = 0; i< a.length; i++) { a[i].draw(); }

Le seguenti righe verranno stampate sulla console:

Cerchio quadrato triangolo vuoto

In questo modo, ogni classe discendente chiamava il proprio metodo di disegno, invece di chiamare il metodo di disegno dalla classe Shape genitore.

Il polimorfismo è una disposizione della teoria dei tipi, secondo la quale i nomi (ad esempio, le variabili) possono denotare oggetti di classi diverse, ma aventi un genitore comune. Di conseguenza, qualsiasi oggetto denotato da un nome polimorfico può rispondere a modo suo a un certo insieme generale di operazioni.

Sovraccarico del metodo, sovraccarico

Nella programmazione procedurale esiste anche il concetto di polimorfismo, che differisce dal meccanismo considerato nell'OOP. Il polimorfismo procedurale implica la possibilità di creare più procedure o funzioni con lo stesso nome, ma passati numeri o tipi di parametri diversi. Tali funzioni con lo stesso nome sono chiamate sovraccariche e il fenomeno stesso è chiamato sovraccarico. L'overload delle funzioni esiste anche in OOP ed è chiamato sovraccarico dei metodi. Un esempio dell'utilizzo dell'overload dei metodi nel linguaggio Java è la classe PrintWriter, che viene utilizzata in particolare per stampare messaggi sulla console. Questa classe ha molti metodi println che differiscono nel tipo e/o nel numero di parametri di input. Eccone solo alcuni:

Void println() // va a una nuova riga void println(boolean x) // stampa il valore di una variabile booleana (true o false) void println(String x) // stampa una stringa - il valore di un parametro di testo

Il polimorfismo è un principio OOP che consente di utilizzare un'interfaccia e diversi algoritmi. L'obiettivo del polimorfismo, applicato all'OOP, è utilizzare un nome per specificare azioni diverse. L'esecuzione dell'azione sarà determinata dal tipo di dati.

Tipi di polimorfismo:

Statico (determinato in fase di compilazione). Sovraccarico di funzioni, metodi, operatori, ecc.

Dinamico (determinato in fase di esecuzione). Contiene funzioni e metodi virtuali.

22. Ereditarietà come meccanismo per implementare il polimorfismo e creare gerarchie di classi. Tipi di eredità.

L'ereditarietà è un meccanismo OOP attraverso il quale vengono create nuove classi basate su quelle esistenti. Queste classi ereditano le proprietà e il comportamento delle classi base e possono acquisirne di nuovi. Ciò consente di ridurre le dimensioni del programma e i tempi per il suo sviluppo. Il polimorfismo ci consente di scrivere programmi per gestire un'ampia varietà di classi logicamente correlate. L'ereditarietà e il polimorfismo sono tecniche efficaci per lo sviluppo di programmi complessi.

Tipi di eredità: diretta e indiretta, semplice e multipla.

23. Classi. Essenziale, derivato, polimorfico, astratto, virtuale. Esempi.

Una classe è un tipo di dati speciale che descrive sia gli attributi dei dati che le azioni eseguite sugli attributi.

Una classe base è una classe i cui membri vengono ereditati.

Una classe derivata è una classe che eredita altri membri.

Una classe polimorfica è una classe contenente metodi virtuali.

Una classe astratta è una classe contenente metodi puramente virtuali.

Una classe virtuale è una classe che, durante l'ereditarietà multipla, non è inclusa nelle classi discendenti, ma viene sostituita da un riferimento in esse, per evitare duplicazioni.

24. Principi di vincolatura anticipata e tardiva.

Il bind è la procedura che stabilisce una connessione tra un identificatore utilizzato in un codice di programma e il suo oggetto fisico (in generale, qualsiasi componente software: variabile, procedura, modulo, applicazione, ecc.)

L'associazione anticipata è l'istituzione di tali connessioni prima che il programma inizi l'esecuzione. Questo di solito significa collegare i moduli sorgente e collegare il modulo eseguibile dai moduli oggetto durante il processo di compilazione.

L'associazione tardiva è l'instaurazione di connessioni durante l'esecuzione del programma. Di solito parliamo di connessioni dinamiche (quando solo durante il funzionamento dell'applicazione viene determinato quali oggetti saranno necessari) o della formazione di tali oggetti durante il funzionamento.

25. Utilizzo di UML per le specifiche

26. Descrizione delle gerarchie di classi con diagrammi uml.

Relazioni di classe attraverso . E mostrano relazioni diverse: dirette, indirette, multiple.

27. Classi modello. Descrizione in um.

Un modello di classe è uno strumento del linguaggio C++ progettato per codificare algoritmi di classe generalizzati, senza riferimento a determinati parametri (ad esempio, tipi di dati, dimensioni del buffer, valori predefiniti).

Sintassi:

modello

classe NOME_CLASS

NOME_CLASSE B; //Chiamata

linfa 20 agosto 2008 alle 19:09

Polimorfismo per principianti

• PHP

Il polimorfismo è uno dei tre principali paradigmi OOP. In breve, il polimorfismo è la capacità di un oggetto di utilizzare metodi di una classe derivata che non esiste nel momento in cui viene creata quella base. Per coloro che non sono particolarmente esperti di OOP, probabilmente sembra complicato. Pertanto, esaminiamo l'uso del polimorfismo utilizzando un esempio.

Formulazione del problema

Supponiamo che il sito abbia bisogno di tre tipi di pubblicazioni: notizie, annunci e articoli. In un certo senso sono simili: hanno tutti un titolo e un testo, le notizie e gli annunci hanno una data. In un certo senso sono diversi: gli articoli hanno autori, le notizie hanno fonti e gli annunci hanno una data dopo la quale diventano irrilevanti.

Le opzioni più semplici che mi vengono in mente sono scrivere tre classi separate e lavorare con esse. Oppure scrivi una classe che conterrà tutte le proprietà inerenti a tutti e tre i tipi di pubblicazioni e verranno utilizzate solo quelle necessarie. Ma per tipi diversi, metodi simili nella logica dovrebbero funzionare in modo diverso. Creare diversi metodi dello stesso tipo per tipi diversi (get_news, get_announcements, get_articles) è completamente ignorante. È qui che il polimorfismo torna utile.

Classe astratta

In parole povere, questa è una classe modello. Implementa funzionalità solo al livello al quale è attualmente noto. Le classi derivate lo completano. Ma è ora di passare dalla teoria alla pratica. Faccio subito una prenotazione: stiamo considerando un esempio primitivo con funzionalità minime. Tutte le spiegazioni sono nei commenti nel codice.

pubblicazione della classe astratta
{
// tabella che memorizza i dati sull'elemento
$tabella protetta;

// le proprietà degli elementi ci sono sconosciute
$proprietà protette = array();

// costruttore

{
// nota che non sappiamo da quale tabella dobbiamo ottenere i dati
$risultato = mysql_query ("SELECT * FROM `" . $this -> table . "` WHERE `id`="" . $id . "" LIMITE 1" );
// non sappiamo nemmeno quali dati abbiamo ricevuto
$this -> proprietà = mysql_fetch_assoc ($risultato);
}

// il metodo, uguale per qualsiasi tipo di pubblicazione, restituisce il valore della proprietà
funzione pubblica get_property ($nome)
{
if (isset($this -> proprietà [$nome]))
return $this -> proprietà [$name];

Restituisce falso;
}

// il metodo, uguale per qualsiasi tipo di pubblicazione, imposta il valore della proprietà
funzione pubblica set_property ($nome, $valore)
{
if (!isset($this -> proprietà [$nome]))
restituire falso;

$questo -> proprietà [$nome] = $valore;

Restituisce $valore;
}

// e questo metodo dovrebbe stampare la pubblicazione, ma non sappiamo come fare esattamente, e quindi lo dichiariamo abstract
funzione pubblica astratta do_print();
}

Classi derivate

Ora puoi passare alla creazione di classi derivate che implementano la funzionalità mancante.

la classe Notizie estende la pubblicazione
{
// costruttore della classe news, derivata dalla classe pubblicazioni
funzione pubblica __construct ($id)
{
// imposta il valore della tabella in cui sono archiviati i dati delle notizie
$questo -> tabella = "tabella_notizie";
genitore :: __costrutto ($id);
}

Funzione pubblica do_print()
{
echo $this -> proprietà ["titolo"];
eco "

" ;
echo $this -> proprietà ["testo"];
eco "
Fonte: " . $this -> proprietà ["fonte"];
}
}

L'annuncio della lezione estende la pubblicazione
{
// costruttore della classe di annunci derivata dalla classe di pubblicazione
funzione pubblica __construct ($id)
{
// imposta il valore della tabella in cui sono archiviati i dati degli annunci
$this -> tabella = "tabella_annunci";
// chiama il costruttore della classe genitore
genitore :: __costrutto ($id);
}

// sovrascrive il metodo di stampa astratta
funzione pubblica do_print()
{
echo $this -> proprietà ["titolo"];
eco "
Attenzione! L'annuncio è valido fino al". $this -> proprietà ["end_date"];
eco "

" . $this -> proprietà ["testo"];
}
}

L'articolo di classe estende la pubblicazione
{
// costruttore della classe articolo, derivata dalla classe pubblicazione
funzione pubblica __construct ($id)
{
// imposta il valore della tabella in cui sono archiviati i dati sugli articoli
$questo -> tabella = "tabella_articoli";
// chiama il costruttore della classe genitore
genitore :: __costrutto ($id);
}

// sovrascrive il metodo di stampa astratta
funzione pubblica do_print()
{
echo $this -> proprietà ["titolo"];
eco "

" ;
echo $this -> proprietà ["testo"];
eco "
" . $this -> proprietà ["autore"];
}
}

Ora sull'uso

Il punto è che lo stesso codice viene utilizzato per oggetti di classi diverse.

// riempie l'array di pubblicazione con oggetti derivati ​​da Publication
$pubblicazioni = nuove notizie ($news_id);
$pubblicazioni = nuovo annuncio($annuncio_id);
$pubblicazioni = nuovo articolo($article_id);

Foreach ($pubblicazioni come $pubblicazione) (
// se lavoriamo con gli eredi della pubblicazione
if ($istanza di pubblicazione della pubblicazione) (
// quindi stampa i dati
$pubblicazione -> do_print();
) altro (
// gestione di eccezioni o errori
}
}

È tutto. Con un leggero movimento della mano i pantaloni si trasformano in eleganti shorts :-).

Il vantaggio principale del polimorfismo è la facilità con cui possono essere create nuove classi che si comportano in modo simile a quelle correlate, il che a sua volta consente estensibilità e modificabilità. L'articolo mostra solo un esempio primitivo, ma mostra anche come l'uso delle astrazioni possa facilitare lo sviluppo. Possiamo lavorare con le notizie proprio come facciamo con la pubblicità o gli articoli, e non dobbiamo nemmeno sapere con cosa stiamo lavorando! Nelle applicazioni reali, molto più complesse, questo vantaggio è ancora maggiore.

Una piccola teoria

• I metodi che richiedono l'override sono detti astratti. È logico che se una classe contiene almeno un metodo astratto, allora è anche astratta.
• Ovviamente non è possibile creare un oggetto di una classe astratta, altrimenti non sarebbe astratto.
• Una classe derivata dispone di proprietà e metodi che appartengono alla classe base e può anche avere metodi e proprietà propri.
• Un metodo sottoposto a override in una classe derivata è chiamato metodo virtuale. Non ci sono informazioni su questo metodo nella classe astratta di base.
• Lo scopo dell'astrazione è definire un metodo nel luogo in cui sono disponibili le informazioni più complete su come dovrebbe funzionare.

AGGIORNAMENTO: Per quanto riguarda le violazioni sql-inj e MVC, signori, questo è solo un esempio, e un esempio di polimorfismo, in cui non ritengo necessario prestare attenzione a queste cose. Questo è un argomento per articoli completamente diversi.

La programmazione è il processo di sviluppo di soluzioni a problemi dinamici “vivi” sotto forma di strutture rigide di codice, dati, funzioni e algoritmi. La procedura per formare una sintassi rigorosa da una semantica vaga. I problemi del mondo reale sono un grosso problema ben noto nell'algoritmo: per ottenere la soluzione desiderata, il problema deve essere collocato in strutture sintattiche precise.

L'OOP ha tentato due volte di "rompere" questo antico concetto di programmazione, ma le "catene" dello stile classico di codifica dei dati e degli algoritmi sono ancora forti.

Livello e qualifiche

L'informatica ha iniziato con i calcoli, ma la velocità con cui sta aumentando l'accelerazione del movimento nel campo dell'elaborazione delle informazioni non è ancora abbastanza veloce perché la programmazione classica diventi impossibile e cessi di esistere.

È anche oggettivo che lo sviluppatore non insista e che il cliente non richieda una soluzione reale a problemi reali. Entrambe le parti sono abituate a essere limitate dagli strumenti disponibili e dalle capacità familiari.

Forme di polimorfismo OOP, idee di incapsulamento del codice e ereditarietà delle proprietà (metodi) si trovano nell'ambito della programmazione, ma non nell'ambito del problema da risolvere.

Un esempio calzante è la libreria PHPOffice/PHPWord. Per utilizzarlo servono qualifiche da sviluppatore, è necessario creare un proprio sistema di oggetti, ma il livello attuale del cliente (requisiti del cliente) è una composizione banale che il programmatore copre con il proprio sviluppo (altrimenti i requisiti non possono essere soddisfatti ). La situazione è più o meno questa:

In questo caso, l'utilizzo di una biblioteca è compito della formattazione del documento, ad esempio un diploma o una tesi devono essere formattati secondo lo standard. Il cliente ha presentato le sue richieste e il programmatore è andato ben oltre.

È stata eseguita un'analisi completa del documento, il suo assemblaggio nel formato richiesto, il lavoro con tabelle di qualsiasi livello di nidificazione, l'unione e la divisione di celle, la stampa in qualsiasi direzione, ecc.

Polimorfismo e OOP

Non riesco a pensare a una definizione migliore di polimorfismo che fare riferimento alla storia dello sviluppo dell'idea di programmazione orientata agli oggetti, così popolare oggi, così spesso usata, ma non realizzato in sostanza lo è ancora.

• incapsulamento;
• polimorfismo;
• eredità.

Alcuni aggiungono anche: l'astrazione, e molto spesso questo, e in realtà il punto principale, viene utilizzata come base per descrivere l'essenza dell'OOP.

Quindi, le opinioni sull'OOP sono polimorfiche: descrivono una cosa, sono progettate in modo diverso o, al contrario, descrivono cose diverse, ma si basano su quattro posizioni identiche.

Il principio democratico non è caratteristico del campo dell'informatica, ma gli va dato il dovuto: la combinazione e la coesistenza di molte opinioni sulla stessa cosa è un vero polimorfismo in azione.

Definizioni popolari di polimorfismo

L'OOP è la fase successiva nello sviluppo della tecnologia dell'informazione. Poche persone discutono con questo, ma i suoi assiomi e disposizioni principali differiscono così tanto in termini di semantica che non meritano attenzione al di fuori della loro totalità.

1. Il polimorfismo nella programmazione è la capacità di fornire la stessa interfaccia per diversi moduli sottostanti (tipi di dati).
2. Il polimorfismo è la capacità degli oggetti di avere implementazioni diverse.
3. Il polimorfismo è la capacità di una funzione...
4. Classico (dal creatore di C/C++): "un'interfaccia - molte implementazioni".
5. Polimorfismo parametrico significa...
6. Il polimorfismo è una disposizione della teoria dei tipi...
7. L’astrazione è impossibile senza incapsulamento ed ereditarietà, proprio come il polimorfismo è impossibile senza ereditarietà…

Possiamo convenire che tutto ciò si riferisce alla stessa cosa: ma la forma di espressione del pensiero, l'essenza e il contenuto non sono simili. Ma c'è ancora qualcosa in comune.

Entità: sviluppatore - cliente

Lo sviluppo classico del programma presuppone la presenza di un programmatore e di un compito (cliente, cliente). Un programmatore esamina un problema, lo formalizza e crea il codice che porta a una soluzione. Il cliente nega tutto o solo una parte della proposta, sottolineando i difetti, e il programmatore rifa il suo lavoro.

Questo ciclo del processo di risoluzione del problema suggerisce che qui sono chiaramente combinate due entità completamente diverse:

• il computer non può risolvere il problema da solo;
• è necessario un programma affinché il computer possa “capire” e “risolvere” il problema.

Il compito è la sfera di competenza del cliente, il programma è un algoritmo per “adattare” il compito alle capacità del computer - la sfera di competenza del programmatore. Il ruolo di quest'ultimo è quello di “adattare” il computer alle esigenze del compito, e questo non è necessario!

Offerte astratto. Ci sono oggetti: questa è la sfera del cliente; c'è l'implementazione degli oggetti: questa è la sfera del programmatore. Non esiste alcun collegamento “tecnologico” tra cliente e sviluppatore. L'idea è radicale, fino ad oggi non è stata implementata, ma qualcosa sta già funzionando stabilmente.

Finestre, pulsanti e altri oggetti

La storia di Air Art Technology, Object Magazine, Turbo Vision, Graph Vision è già storia. Poche persone ricordano queste implementazioni di OOP, sono praticamente inutilizzate e dimenticate, ma l'interfaccia della finestra di Windows è familiare a milioni di utenti e gli oggetti in PHP, JavaScript e altri linguaggi tecnologici Internet sono utilizzati da centinaia di migliaia di sviluppatori di codice, e milioni di visitatori delle risorse web li conoscono.

Questo è probabilmente l'unico modo corretto in cui l'OOP avrebbe dovuto svilupparsi: incapsulamento, ereditarietà, polimorfismo per lo sviluppatore, ma non per l'utente. È caratteristico che questa posizione sia stata la principale nello sviluppo della progettazione visiva (interfaccia) di software Windows e programmi applicativi come Turbo Vision e Graph Vision.

Il concetto alla base di prodotti come Air Art Technology e Object Magazine era significativamente diverso. In questo caso, l'oggetto astratto è stato il primo antenato della struttura informativa, incapsulando il codice di elaborazione dell'informazione a livello astratto. Gli oggetti come finestre, pulsanti ed elementi di design visivo erano qui secondari.

Nella prima versione (Windows ecc.), il paradigma OOP: incapsulamento, ereditarietà, polimorfismo era designato a livello di un antenato astratto e l'implementazione del codice era formata a livello di ciascun discendente specifico lungo il ramo ereditario secondo alla struttura e al contenuto richiesti.

Nella seconda opzione (Air Art Technology e Object Magazine), il livello dell'oggetto astratto è importante. Ciò che avrà un determinato discendente non è importante, l'importante è che il suo ramo ereditario soddisfi le esigenze di tutti i genitori fino all'astrazione della radice.

Oggetto e sistema di oggetti: algoritmo

Un concetto ideale orientato agli oggetti può manipolare solo oggetti e sistemi di oggetti.

Nei moderni linguaggi di programmazione, un oggetto (classe) è solitamente inteso come una descrizione di un oggetto e un'istanza di un oggetto e, per utilizzare la descrizione di un oggetto, i linguaggi consentono al programmatore di lavorare con oggetti statici, mentre un oggetto dinamico - descrizioni, con il proprio contenuto e la propria struttura unici, ma utilizzando gli stessi metodi (proprietà) della descrizione.

La pratica attuale collega il concetto di oggetto a uno strumento, cioè a un linguaggio di programmazione, un'interfaccia, un accesso al database, una connessione di rete, ma non c'è nulla che indichi gli interessi del cliente, il problema da risolvere.

Questo è l'ideale per l'OOP semplice: il polimorfismo consente di creare, in particolare, una varietà di elementi di design, ma gestirli con lo stesso codice. Ma qui non stiamo parlando degli oggetti del problema, che non è affatto considerato oggetto di analisi orientata agli oggetti.

I programmatori hanno adottato l'OOP come mezzo per migliorare la qualità e la produttività del proprio lavoro, ma non hanno ceduto un solo frammento del “loro territorio” al cliente. I concetti di base dell'OOP - incapsulamento, ereditarietà, polimorfismo - sono rimasti nell'area di sviluppo e non sono stati trapiantati nell'area delle attività.

Oggetto e sistema di oggetti: problema e soluzione

Computer - programmatore - compito. Il collegamento centrale è ridondante. Idealmente, dovrebbero esserci solo due circuiti, relativamente dipendenti: (computer - programmatore) - compito. Cioè, l'utente, il cliente o il visitatore ha uno strumento per risolvere il suo problema. Al cliente non interessa come viene implementato lo strumento.

Idealmente, questo è solo un computer in grado di capire cosa vuole il cliente e fare ciò che vuole. Come sarà: un programma locale o un sito Web accessibile tramite un browser, un programma speciale per l'elaborazione distribuita delle informazioni, un sistema informativo per il cliente: non importa.

È importante che non vi sia alcun collegamento non necessario tra il compito e il computer, ma che il primo venga compreso e risolto dal secondo. Per raggiungere questo obiettivo, il computer e il cliente devono essere collegati da un sistema di oggetti, e il significato, la struttura e il contenuto di ciascun oggetto sono determinati dal cliente, e i metodi e le proprietà degli oggetti sono implementati dal programmatore.

È ideale quando il lavoro del cliente sulla creazione del sistema di oggetti di cui ha bisogno e il lavoro sull'implementazione dei metodi e delle proprietà di questi oggetti sono separati nel tempo. Quanto più l'implementazione di un sistema di oggetti (programmatore) è lontana dal suo contenuto semantico (cliente), tanto migliore è la qualità del processo.

Niente impedisce al cliente e al programmatore di interagire nel processo di risoluzione del problema, ma è importante una chiara separazione della semantica. Ognuno dovrebbe farsi gli affari propri, il programmatore non è obbligato a padroneggiare la portata del compito e il cliente non dovrebbe comprendere il codice e, inoltre, le parti non dovrebbero darsi consigli a vicenda su ciò che non li riguarda.

Programmazione tradizionale e ad oggetti

I postulati di base dell'OOP: incapsulamento, ereditarietà, polimorfismo nella forma in cui sono diventati familiari e richiesti, portano ad un notevole miglioramento della qualità e dell'affidabilità del codice, accelerano significativamente il lavoro del programmatore e hanno molto di altre qualità positive.

Ma le cose stanno ancora lì: la programmazione classica non è inferiore alle sue posizioni e molte idee orientate agli oggetti sono implementate nel codice classico.

Tuttavia, le idee di OOP e di ricorsione hanno portato ad un'influenza adeguata sulla sintassi degli operatori di sintassi classici, sulla logica della costruzione del codice ordinario che non ha nulla a che fare con lo stile di scrittura e di pensiero orientato agli oggetti.

Elenchi e code furono trasformati, apparve il concetto del primo e dell'ultimo elemento di un array, apparvero i cicli "for Each" e le opzioni di riferimento per la denominazione, l'utilizzo e l'esecuzione divennero ancora più popolari di prima.

In realtà, il fatto stesso che le variabili abbiano perso il loro aspetto "chiaro" (il tipo di una variabile può cambiare secondo necessità e non è affatto necessario descrivere una variabile) dice che i classici, infatti, sono diventati molto tempo fa oggetti- orientato e riconosciuto i principi di base dell'OOP: incapsulamento, ereditarietà, polimorfismo come idee di significativa importanza.

Su cosa si basa: un oggetto o un sistema?

L'astrazione, come principale posizione concettuale dell'OOP, indipendentemente da dove si trova l'area di responsabilità (implementazione) dell'oggetto - a livello del primo oggetto astratto o a livello di un discendente specifico - lascia aperta la questione: da dove cominciare tutto, dall'oggetto o dal sistema?

Se metti un oggetto come base, non diventerà mai un sistema, poiché il sistema sarà al suo interno e diventerà esso stesso un'immagine rigida di un inizio molto specifico. Qui sorgono problemi con l'astrazione: l'oggetto iniziale cattura con precisione la cosa principale nel problema da risolvere, cioè non è più trasferibile a un altro problema.

Se lo basiamo su un sistema di oggetti, otteniamo un sistema di sistemi. Questo è difficile da immaginare in relazione a un compito specifico e anche da dove iniziare lo sviluppo è difficile da capire. In generale, il polimorfismo dell'OOP con le sue differenze nelle entità, nelle forme di implementazione e nel numero di parametri effettivi nelle funzioni dà un'idea del sistema che si trova all'inizio come:

• sulle opzioni per risolvere un problema (ad esempio un menu);
• sulle condizioni iniziali (applicazione del problema in diverse condizioni, dati);
• sulle modalità operative (test, impostazione, funzionamento).

Ma questo ed altri simili non danno motivo di basare la soluzione del problema su un sistema di oggetti. Spesso è sufficiente definire un singolo oggetto iniziale.

Storia del processo di risoluzione dei problemi

I principi più importanti dell'OOP: polimorfismo e astrazione: danno la priorità all'oggetto iniziale come sistema di oggetti. In un dibattito su chi debba venire prima, tra l’uovo e la gallina, qui vince la gallina.

Non c'è dubbio che tutto debba cominciare da un oggetto astratto e non da un sistema di oggetti. Ma se teniamo conto del fattore tempo e lo applichiamo a livello di ciascun oggetto, partendo dal primo astratto, allora l’idea contraddittoria di mettere sia l’oggetto che il sistema all’inizio della decisione diventa solo ragionevole.

Se il concetto classico di programmazione, nel corso della risoluzione di un problema, modifica i dati, il contenuto del database, modifica i file, ecc., allora nel concetto di OOP, il polimorfismo, l'incapsulamento e il fattore tempo cambiano il contenuto, la struttura e proprietà del sistema di oggetti del problema da risolvere.

Un programmatore in OOP è meno interessato al concetto di file, database, algoritmo: questi sono dettagli; qui il programmatore pensa per oggetti, ma gli oggetti esistono nel tempo e cambiano nel corso del raggiungimento del desiderato.

Quindi, all'inizio c'è l'oggetto come sistema di oggetti e la logica di questo sistema - la scala temporale: avviare un compito, formare il primo oggetto, inserire o raccogliere dati, formare l'oggetto successivo, ma nulla impedisce al primo oggetto di procedere alla soluzione successiva.

Ogni livello di oggetti agisce come un sistema di oggetti indipendente, cioè è un oggetto, ma nel contesto del processo iniziato e del significato del tempo, è un sistema di oggetti su scala temporale. Per una completa implementazione dell'OOP, il polimorfismo, l'ereditarietà e il fattore tempo garantiscono insieme la dinamica del primo, ovvero un oggetto non solo può cambiare nel tempo, ma anche generare oggetti non previsti dallo sviluppatore, generati dall'esecuzione di un compito durante il processo, progettato dal cliente.

Polimorfismo OOP reale, esempio

La complessità dei problemi che l'OOP può risolvere non è paragonabile a ciò che è possibile fare con la versione classica dei programmi di scrittura. Naturalmente, è sempre possibile risolvere qualsiasi problema nel solito modo, ma la questione di quanto "costerà" tempo e fatica spesso rende il risultato inutile.

La libreria PHPOffice/PHPWord è stata sviluppata non molto tempo fa, ma per sfruttare le sue capacità è quasi sempre necessario creare il proprio sistema di oggetti. Ad esempio, un semplice file *.docx:

è un archivio zip di molti file e cartelle nel formato Office Open XML (OpenXML, OOXML). Ogni file è scritto in tag XML e quando si aggiungono, si modificano e si eliminano lettere, parole, tabelle, elenchi e altri elementi, il contenuto dei file inizia a rappresentare una sequenza di tag che non sempre contengono elementi completi; spesso un elemento è scritto con molti tag.

Se immagini questo file come una sequenza di tag, ottieni un'immagine interessante:

È facile notare che il primo ed unico paragrafo del documento è rappresentato da numerosi tag. Per quanto riguarda la tabella e le tabelle in essa integrate, il volume della descrizione di tutti gli elementi non può essere percepito, ma è accessibile ad un'applicazione orientata agli oggetti.

Infatti, nella figura, il verde è l'output del test dei tag, il giallo sono i parametri e la tipologia del tag, e il beige è il contenuto. Gli oggetti creati sono orientati alla lavorazione meccanica. Solo le operazioni di apertura di un file di documento, formattazione e scrittura diventano disponibili per una persona.

La soluzione è semplice e pratica, ma l'implementazione è più orientata al computer che all'uomo a causa del volume di funzionalità eseguite e delle complesse relazioni tra gli oggetti.

Stato dell'area OOP

Lo sviluppo di sistemi di gestione dei siti web, le tecnologie per l'impostazione e la gestione dei server e l'esperienza nello sviluppo di siti web dinamici hanno reso la programmazione orientata agli oggetti accessibile a tutti. Il problema è come cambiare il tuo modo di pensare e abituarti a pensare a livello di oggetti e non nel contesto del codice eseguito in sequenza.

Solitamente il passaggio dalla programmazione classica alla programmazione orientata agli oggetti richiede dai due ai tre mesi, ma i costi ne valgono la pena. Il potenziale dei moderni linguaggi di programmazione, in primis PHP e JavaScript, soddisferà lo sviluppatore più sofisticato.

L'OOP moderno - polimorfismo, ereditarietà e capacità di formare proprietà dell'oggetto - è comodo e pratico, la sintassi del linguaggio e gli strumenti ausiliari garantiscono facilità d'uso ed efficienza del codice.

Prospettive sull'idea di oggetto

È abbastanza difficile dire quanto durerà la programmazione classica e come si svilupperà l’OOP. A quanto pare, gli sviluppatori di strumenti non intendono considerare il contesto del consumatore (utente, cliente).

Gli strumenti OOP (polimorfismo, ereditarietà, incapsulamento e astrazione) sono orientati agli sviluppatori.

I moderni sistemi informativi e le risorse web si sforzano di riflettere la realtà, garantire il funzionamento di oggetti reali e creare un ambiente per il loro funzionamento così semplice da essere accessibile a un consumatore lontano dalla programmazione e completamente immerso nella propria area di competenza. competenza.