Impara a conoscere le strutture dati che usi ogni giorno.

👋 Benvenuto! Iniziamo con un po' di necessario contesto. Ho qualche domanda per te:
✅ Ascolti musica sul tuo smartphone?
✅ Mantieni un elenco di contatti sul telefono?
✅ Hai mai visto una classifica durante una competizione?

Se la tua risposta è "sì" a una qualsiasi di queste domande, allora è quasi certo che hai usato gli array e non lo sapevi nemmeno! 😃 Gli array sono strutture di dati molto potenti che memorizzano elenchi di elementi. Hanno infinite applicazioni. Sono molto importanti nel mondo dell'informatica.

In questo articolo imparerai i pro e i contro degli array, la loro struttura, le operazioni che puoi eseguire su di essi e i casi d'uso.

Cominciamo! 👍

🔎 Approfondimento della struttura di base degli array

Per capire come funzionano, è molto utile visualizzare la memoria del tuo computer come una griglia, proprio come quella qui sotto. Ogni parte di informazione viene conservata in uno di quei piccoli elementi (i quadrati) che compongono la griglia.

Gli array si avvalgono di questa struttura a "griglia" per conservare elenchi di informazioni correlate in posizioni di memoria adiacenti al fine di garantire estrema efficienza nel trovare questi valori. 🔳🔳🔳🔳

Puoi visualizzare la struttura di un array in questo modo:

Gli elementi di un array sono adiacenti nella memoria. Se devi accedere a più di uno di essi, il processo è estremamente ottimizzato in quanto il tuo computer sa già dove si trova il valore.

Stupendo, non è vero? Impariamo come avviene dietro le quinte! 😃

📚 Classificazione

Gli array sono classificati come Strutture Dati Omogenee in quanto conservano elementi dello stesso tipo.

Possono conservare numeri, stringhe, valori booleani (vero e falso), caratteri, oggetti e così via. Ma una volta definito il tipo di valore che dovrà contenere il tuo array, tutti i suoi elementi dovranno essere dello stesso tipo. Non puoi "mischiare" elementi di tipi diversi.

👀 Leggere Valori — La Magia Inizia!

Il meraviglioso potere degli array proviene direttamente dalla loro efficienza nell'accedere ai valori. Questo avviene grazie alla loro struttura tipo griglia. Esaminiamo il processo in maggiore dettaglio.🔍

Quando crei un array:
- Lo assegni a una variabile. 👈
- Definisci il tipo di elementi che dovrà contenere. 🎈
- Definisci la sua dimensione (il numero massimo di elementi). 📚

💡 Nota: Il nome che assegni a questa variabile è molto importante in quanto lo utilizzerai successivamente nel tuo codice per accedere e/o modificarne i valori.

Ma come puoi dire al computer di accedere a un particolare valore? Qui gli indici hanno un ruolo vitale!

1️⃣ Indici

Si usa quello che viene chiamato "indice" per accedere a un valore in un array. È un numero che fa riferimento alla posizione in cui il valore è conservato.

Come puoi vedere nel diagramma qui sotto, il primo elemento dell'array viene indirizzato usando l'indice 0. Mano a mano che ti sposti verso destra, il valore dell'indice aumenta di uno per ciascuno spazio in memoria.

💡 Nota: So che partire a contare da 0 invece che da 1 può sembrare strano, ma è quella che viene chiamata Numerazione a base zero. È molto comune in informatica.

La sintassi generale per accedere a un elemento è <VariabileArray>[<indice>]

Per esempio:
Se il tuo array è associato alla variabile myArray e vuoi accedere al primo elemento (indice 0), dovresti usare myArray[0]

2️⃣ Memoria

Ora che sai come accedere ai valori, vediamo come sono conservati gli array nella memoria del computer. Quando definisci la dimensione di un array, tutto lo spazio in memoria corrispondente alla dimensione viene "riservato" da quel momento in poi per valori futuri che vorresti poter inserire.

💡 Nota: Se non riempi tutto l'array con valori, quello spazio verrà riservato e mantenuto vuoto fino a quando non lo farai.

Per esempio:
Diciamo che definisci un array di dimensione 5 ma inserisci un solo valore. Tutto lo spazio rimanente sarà vuoto e "riservato" in memoria, in attesa di future assegnazioni.

Questa è la chiave: gli array sono estremamente efficienti nell'accedere ai valori in quanto tutti gli elementi sono conservati in spazi contigui di memoria. In questo modo, il computer sa esattamente dove cercare per trovare le informazioni che hai richiesto.

Ma… c'è un aspetto negativo 😞 in quanto non è efficiente dal punto di vista della memoria. Stai riservando memoria per operazioni future che potrebbero non accadere mai. Ecco perché gli array sono consigliati in situazioni dove sai in anticipo quanti elementi andrai a conservare.

🔧 Operazioni — Dietro le quinte!

Ora che sai cosa sono gli array, quando vengono usati e come conservano i loro elementi, approfondiremo le operazioni che si possono compiere su di essi come l'inserimento e l'eliminazione.

1️⃣ Inserimento — Benvenuto!

Supponiamo di avere un array di dimensione 6 e di avere ancora spazio vuoto all'interno. Vogliamo inserire un elemento "e" all'inizio dell'array (indice 0), ma questa posizione è già occupata dall'elemento "a". Cosa dovremmo fare?

Per inserire elementi negli array, spostiamo tutti gli elementi già presenti che si trovano alla destra della posizione di inserimento di una posizione in avanti verso destra. L'elemento "a" ora sarà a indice 1, l'elemento "b" a indice 2 e così via…

💡 Nota: Potresti aver bisogno di creare una variabile per tenere traccia del valore dell'ultimo indice che contiene elementi. Nel diagramma qui sopra, l'array viene riempito fino all'indice 4 prima dell'inserimento. In questo modo, puoi determinare se l'array è pieno e quale indice dovresti utilizzare per inserire un elemento alla fine.

Dopo aver fatto questo, il nuovo elemento viene inserito con successo. 👏

⚠️ Aspetta un minuto! Cosa succede se l'array è pieno?

Cosa pensi che accada se l'array è pieno e cerchi di inserire un elemento? 😱

In questo caso devi creare un array nuovo più grande, poi copiare manualmente tutti gli elementi nel nuovo array. Questa operazione è molto onerosa dal punto di vista del tempo. Immagina cosa accadrebbe se avessi un array con milioni di elementi! Potrebbe volerci moltissimo tempo per completare l'operazione. ⏳

💡 Nota: L'unica eccezione a questa regola, laddove l'inserimento è molto veloce, è quando inserisci un elemento alla fine dell'array (alla posizione di indice alla destra dell'ultimo elemento) e c'è ancora spazio disponibile. Questo viene fatto con un tempo costante O(1).

2️⃣ Cancellazione— Ciao Ciao!

Diciamo ora che vuoi eliminare un elemento dall'array.

Per mantenere l'efficienza per l'accesso casuale (essere in grado di accedere in modo estremamente veloce all'array tramite un indice) gli elementi devono essere conservati in spazi contigui di memoria. Non puoi semplicemente eliminare l'elemento e lasciare uno spazio vuoto.

Dovresti spostare di una posizione a sinistra gli elementi situati dopo l'elemento che vuoi cancellare.

Alla fine l'array risulterà questo 👇. Come puoi vedere, "b" è stato eliminato con successo.

💡 Nota: La cancellazione è molto efficiente quando rimuove l'ultimo elemento. Visto che devi creare una variabile che tenga traccia dell'ultimo indice che contiene un elemento (nel diagramma qui sopra, 3), puoi rimuovere direttamente l'elemento usando l'indice.

3️⃣ Trovare un elemento

Hai tre opzioni per trovare un elemento in un array:

• Se conosci la sua posizione, usa l'indice.
• Se non conosci la sua posizione e i tuoi dati sono ordinati, puoi usare degli algoritmi per ottimizzare la tua ricerca, come la Ricerca Binaria.
• Se non conosci la sua posizione e i dati non sono ordinati, devi scorrere tutti gli elementi nell'array e verificare se l'elemento corrente è quello che stai cercando (vedi la serie di diagrammi qui sotto).

👋 Riepilogando …

• Gli array sono strutture dati estremamente potenti che conservano elementi dello stesso tipo. Il tipo degli elementi e la dimensione dell'array sono fissi e definiti in fase di creazione.
• La memoria è allocata immediatamente dopo che l'array è creato ed è vuota fino a quando non assegni i valori.
• Gli elementi sono posti in posizioni contigue di memoria, in modo che vi si possa accedere in modo molto efficiente (accesso casuale O(1) = tempo costante) usando gli indici.
• Gli indici partono da 0, non da 1 come siamo abituati.
• L'inserimento di elementi all'inizio o in mezzo all'array comporta lo spostamento degli elementi verso destra. Se l'array è pieno, occorre creare un nuovo array di maggiori dimensioni (il che non è molto efficiente). L'inserimento alla fine dell'array è molto efficiente - tempo costante O(1).
• La rimozione di elementi dall'inizio o nel mezzo dell'array comporta lo spostamento di tutti gli elementi verso sinistra per evitare di lasciare uno spazio vuoto in memoria. Questo garantisce che gli elementi siano conservati in spazi di memoria contigui. La rimozione di un elemento alla fine dell'array è molto efficiente in quanto cancelli solo l'ultimo elemento senza spostare gli altri.
• Per trovare un elemento, devi controllare l'intero array fino a quando non lo trovi. Se i dati sono ordinati, puoi usare algoritmi come la Ricerca Binaria per ottimizzare il processo.

“Impara dal passato, vivi nel presente, spera nel futuro. La cosa importante è non smettere di fare domande.”

— Albert Einstein

👋 Grazie!

Spero vivamente che ti sia piaciuto il mio articolo. ❤️
Seguimi su Twitter per trovare altri articoli come questo. 😃

Impara a conoscere le strutture dati che usi ogni giorno

👋 Benvenuto! Iniziamo con un po' di necessario contesto. Ho qualche domanda per te:
✅ Usi Google Search?
✅ Usi Google Maps?
✅ Usi i siti di social media?

Se la tua risposta è "sì" a una qualsiasi di queste domande, allora hai sicuramente utilizzato i grafi e non lo sapevi nemmeno! Sorpreso? 😲 Lo ero anch'io! Questo articolo ti fornirà un'introduzione visiva al mondo dei grafi, al loro scopo, elementi e tipi.

Queste strutture di dati hanno davvero attirato la mia attenzione grazie alle loro incredibili capacità. Sono così potenti che non immagini nemmeno quanto possano essere diverse le loro applicazioni nel mondo reale. Cominciamo! 😁

🌐 Applicazioni nel Mondo Reale — La Magia Inizia!

I grafi sono usati in diversi settori e campi:

• I sistemi GPS e Google Maps usano i grafi per trovare il percorso più breve da una destinazione a un'altra.
• I Social Network usano i grafi per rappresentare le connessioni tra utenti.
• L'algoritmo di Google Search usa i grafi per determinare la rilevanza dei risultati della ricerca.
• La Ricerca Operativa è un campo che utilizza i grafi per trovare il percorso ottimale per ridurre i costi di trasporto e consegna di beni e servizi.
• Anche la chimica usa i grafi per rappresentare le molecole!!! ❤️

Le loro applicazioni sono fantastiche, vero?
Iniziamo il nostro viaggio attraverso questo mondo! 😄

🔵 Ti Presento i Grafi!

Ora che hai un po' di contesto, iniziamo parlando del loro scopo principale e degli elementi che li costituiscono.

I grafi sono usati per rappresentare, trovare, analizzare e ottimizzare connessioni tra gli elementi (case, aeroporti, luoghi, utenti, articoli ecc.).

Questo è  un esempio dell'aspetto di un grafo:

💠 Elementi Costitutivi

Sono sicuro che avrai notato due elementi principali nel diagramma qui sopra: dei cerchi e delle linee spesse che li connettono tra loro. Sono chiamati rispettivamente nodi (nodes) e connessioni (edges).

Entriamo nei dettagli! 👍

• Nodi: sono gli  elementi che creano la rete. Potrebbero rappresentare case, luoghi, aeroporti, porti, fermate d'autobus, edifici, utenti, praticamente qualunque cosa tu possa rappresentare come collegata ad altri elementi simili in una rete.
• Connessioni: sono collegamenti tra i nodi. Potrebbero rappresentare strade, voli, percorsi di autobus, una connessione tra due utenti in un social network, o qualunque cosa che potrebbe possibilmente rappresentare una connessione tra nodi nel contesto nel quale stai operando.

😱 Cosa Succede Se Non Ci Sono Connessioni?

Se due nodi non sono collegati tra loro, vuol dire che non esiste connessione diretta tra i medesimi. Ma non ti spaventare! 😩 Potresti essere comunque in grado di andare da un nodo all'altro seguendo una serie di connessioni, come se passassi per diverse strade per raggiungere la tua destinazione finale. 🚛️ 🚛 🚛

Per esempio, nel diagramma qui sotto, sebbene non vi sia diretta connessione tra il nodo viola (a sinistra) e il nodo giallo (a destra), puoi comunque raggiungerlo dal nodo viola passando per il nodo arancione, poi per il nodo rosa, quindi per quello verde e arrivare finalmente al nodo giallo. 🏁

Questo è un aspetto chiave dei grafi, puoi trovare l'elemento desiderato seguendo i percorsi a disposizione.

🌟 Notazione e Terminologia

È molto importante imparare il "linguaggio" formale per lavorare con i grafi:

• |V| = Numero totale di vertici (nodi) in un grafo.
• |E| = Numero totale di connessioni in un grafo.

Nell'esempio che segue,  |V| = 6 in quanto ci sono sei nodi (i cerchi) ed |E| = 7 poiché ci sono sette connessioni (le righe).

📚 Tipi di Grafo

I grafi sono classificati in base alle caratteristiche delle loro connessioni. Vediamoli in dettaglio! 😃

1️⃣ Grafi Orientati

Nei grafi orientati, le connessioni hanno una direzione. Vanno da un nodo all'altro, e non c'è modo di tornare al nodo iniziale usando quella connessione.

Come puoi vedere nel diagramma qui sotto, le connessioni ora hanno delle frecce che puntano verso una specifica direzione. Pensa a queste connessioni come a strade a senso unico. Puoi andare in una direzione per raggiungere la tua destinazione, ma non puoi tornare indietro facendo la stessa strada, devi cercare un percorso alternativo.

🍕 Per esempio se per un servizio di consegna pizza a domicilio creiamo un grafo  che rappresenta una città, due case (i nodi) potrebbero essere connesse da una strada a senso unico. Potresti andare dalla casa A alla casa B passando per questa strada, ma non potresti ritornare, quindi dovresti utilizzare un percorso alternativo.

💡 Nota: In un grafo orientato, potresti non essere in grado di ritornare al tuo luogo di partenza in alcun modo se non esiste un percorso con le direzioni appropriate. 😞 Nel diagramma che segue, puoi notare che puoi andare dal nodo viola a quello verde, ma puoi vedere anche che non c'è modo di tornare dal nodo verde a quello viola, in quanto le connessioni sono "strade a senso unico".

2️⃣ Grafi Non Orientati

In questo tipo di grafi, le connessioni non sono orientate (non hanno una direzione specifica). Pensa a questo tipo di connessioni come a strade a doppio senso. Puoi andare da un nodo all'altro e tornare indietro usando lo stesso "percorso".

💡 Nota: Quando vedi un diagramma di un grafo dove le connessioni non hanno frecce che puntano verso una specifica direzione, puoi assumere che il grafo non è orientato.

🍕 Per il nostro servizio di consegna pizze a domicilio significherebbe che il veicolo per le consegna può andare dalla sorgente alla destinazione e tornare indietro usando la stessa strada o percorso (con sollievo del guidatore! 😇).

Nel grafo qui sotto potresti andare dal nodo viola a quello verde e tornare indietro seguendo lo stesso percorso, quindi non raggiungerai un punto di non ritorno. 😌

🏋 Pesi? — Sì, Pesi!

1️⃣ Grafici Ponderati

Nei grafici ponderati, ciascuna connessione ha un valore associato (chiamato peso). Questo valore viene usato per rappresentare una data relazione quantificabile tra i nodi che collega.

Per esempio i pesi potrebbero rappresentare distanza, tempo, il numero di connessioni condivise tra due utenti in un social network, o qualsiasi cosa che potrebbe essere usata per descrivere la connessione tra nodi nel contesto nel quale stai lavorando.

Questi pesi sono usati dall'algoritmo di Dijkstra per ottimizzare le rotte per trovare i percorsi più brevi o meno costosi tra i nodi in una rete.

2️⃣ Grafi Non Ponderati

Nei grafi non ponderati, al contrario, non abbiamo pesi associati alle loro connessioni. Un esempio di questo tipo di grafo si può trovare nei social network, dove le connessioni tra due utenti non possono essere quantificate. Pertanto la connessione non ha un peso.

💡 Nota: Potresti aver notato che, fino ad ora, i nostri grafi hanno solo una connessione che connette ciascuna coppia di nodi. È normale chiedersi se potrebbero esserci più connessioni tra una coppia di nodi. In effetti questo è possibile con i  Multigrafi! Essi possono avere più connessioni che connettono la stessa coppia di nodi.

🏆 Numero di Connessioni! — Un Fattore Importante

È molto importante sapere se un grafo ha molte o poche connessioni in quanto questo è un fattore cruciale per decidere come vorrai rappresentare questa struttura dati nel tuo codice. Vediamo i diversi tipi! 👍

1️⃣ Grafo Denso

Sono i grafi che hanno molte connessioni. Ma, un momento! ⚠️ So quello che starai pensando, come puoi quantificare "molte connessioni"? Questo è piuttosto soggettivo, giusto? 😇 Sono d'accordo con te, quindi quantifichiamole:

👉 Troviamo il numero massimo di connessioni in un grafo orientato. Se ci sono |V| nodi in un grafo orientato (sei, nell'esempio qui sotto), vuol dire che ogni nodo può avere fino a  |v| connessioni (nell'esempio qui sotto, sei).

Questo perché ogni nodo potrebbe potenzialmente essere connesso con tutti gli altri nodi e con sé stesso (vedi il "loop" qui sotto). Pertanto il numero massimo di connessioni che il grafo può avere è |V|*|V| , che rappresenta il numero totale di nodi moltiplicato per il numero massimo di connessioni che ogni nodo può avere.

Quando il numero di connessioni nel grafo è vicino al numero massimo di connessioni, il grafo è denso. 😉

💡 Nota: I “loop” si verificano quando un nodo ha una connessione che connette se stesso. Strano e interessante, vero? 😄

2️⃣ Grafi Sparsi

I grafi sparsi hanno poche connessioni. Come puoi vedere nel diagramma qui sotto, non ci sono molte connessioni tra i nodi.

Quando il numero di connessioni in un grafo è significativamente minore del numero massimo di connessioni, il grafo è sparso. 😉

⭕️ Ti Presento i Cicli!

Ora vediamo un concetto vitale per comprendere i grafi, i cicli.

Avrai probabilmente notato che, se segui una sequenza di connessioni in un grafo, potresti trovare il percorso che ti riporta allo stesso nodo. Questo è come "girare in tondo", esattamente come se stessi guidando per la tua città e prendessi un percorso che ti potrebbe portare al punto di partenza.

Nei grafi, questi percorsi "circolari" sono chiamati cicli. Sono percorsi validi che iniziano e finiscono allo stesso nodo. Per esempio, nel diagramma qui sotto, puoi vedere che partendo da qualsiasi nodo puoi ritornarci seguendo le connessioni.

I cicli non sono sempre "isolati" in quanto possono fare parte di un grafo più grande. Puoi rilevarli facendo partire la tua ricerca da uno specifico nodo e cercando un percorso che ti riporta allo stesso nodo.

👋 Riepilogando …

• I grafi sono strutture meravigliose che puoi usare quotidianamente tramite Google Search, Google Maps, GPS e i social media.
• Sono usati per rappresentare elementi che condividono connessioni.
• Gli elementi nel grafo sono chiamati nodi (nodes) i collegamenti tra loro connessioni (edges).
• I grafi possono essere orientati, quando le loro connessioni hanno uno specifico orientamento, simili alle strade a senso unico, oppure non orientati, quando le connessioni non hanno un orientamento specifico, simili alle strade a doppio senso.
• Le connessioni possono avere un valore associato ad esse, chiamato peso.
• Se un grafo ha molte connessioni si dice denso, altrimenti, se ha poche connessioni, viene detto sparso.
• Una serie di connessioni può formare un ciclo se esse creano un percorso che ti consente di tornare al nodo di partenza.

Continua ad apprendere queste stupende strutture! Ne varrà sicuramente la pena per il tuo futuro di programmatore. In questo momento sto imparando le strutture dati e le trovo assolutamente affascinanti. 😃 🎆 ❤️

La cosa importante è non smettere di fare domande. La curiosità esiste per ragioni proprie. — Albert Einstein

👋 Grazie!

Spero davvero che tu abbia apprezzato il mio articolo. ❤️
Seguimi su Twitter. 😃

Hai notato come durante i colloqui di lavoro vengono fatte sempre le stesse domande, ancora e ancora?

Sono sicuro che sai cosa voglio dire.

Ad esempio:

Dove ti vedi tra cinque anni?

o ancora peggio:

Quale pensi che sia il tuo più grande punto debole?

Datemi tregua. Rispondere a questo domanda è un punto debole! In ogni caso, non è questo il punto.

Saranno anche delle domande banali, ma sono importanti perché danno delle informazioni su di te: il tuo stato d'animo attuale, la tua mentalità, il tuo punto di vista.

Quando rispondi, dovresti fare attenzione, per evitare di dire cose di cui potresti pentirti.

Oggi voglio parlare di una domanda di una tipologia simile a questa nel mondo della programmazione:

Quali sono i principi fondamentali della programmazione orientata agli oggetti?

Mi sono trovato da entrambi i lati di questa domanda. È uno di quegli argomenti che vengono chiesti spesso e che non puoi permetterti di non conoscere.

Di solito, gli sviluppatori junior ed entry-level si trovano a dover rispondere a questa domanda, perché è un modo per chi gestisce il colloquio per capire tre cose:

1. Il candidato si è preparato per il colloquio?
   Punti bonus per una risposta immediata — dimostra un approccio serio.
2. Il candidato ha passato la fase tutorial?
   Capire i principi della programmazione orientata agli oggetti (OOP) dimostra di essere andati oltre il copia e incolla dai tutorial e di vedere le cose da una prospettiva più alta.
3. Il candidato possiede una comprensione profonda o superficiale?
   Il livello di competenza su questo argomento spesso eguaglia quello di molti altri. Fidati.

I quattro principi della programmazione orientata agli oggetti sono incapsulamento, astrazione, ereditarietà e polimorfismo.

Queste parole potrebbe spaventare uno sviluppatore principiante. E, nel complesso, le spiegazioni eccessivamente lunghe su Wikipedia a volte raddoppiano la confusione.

Ed è per questo che voglio fornire una spiegazione semplice, breve e chiara per ognuno di questi concetti. Potrebbe sembrare qualcosa da spiegare a un bambino, ma in realtà è proprio ciò che vorrei sentirmi rispondere durante un colloquio.

Incapsulamento

Diciamo di avere un programma con pochi oggetti che hanno diverse logiche e che possono comunicare tra di loro – secondo le regole definite nel programma.

L'incapsulamento viene raggiunto quando ogni oggetto mantiene privato il suo stato all'interno di una classe. Gli altri oggetti non hanno accesso diretto al suo stato, ma possono soltanto chiamare una lista di funzioni pubbliche – chiamate metodi.

Quindi, l'oggetto gestisce il suo stato attraverso dei metodi – e nessuna altra classe può modificarlo se non autorizzata esplicitamente. Se vuoi comunicare con l'oggetto, dovresti usare i metodi forniti, ma (di default) non puoi cambiarne lo stato.

Diciamo che stai costruendo un piccolo gioco di simulazione. Ci sono delle persone e c'è un gatto, che comunicano tra di loro. Vogliamo applicare l'incapsulamento, quindi incapsuliamo tutta la logica del gatto nella classe Cat. Potrebbe avere questo aspetto:

In questo caso, lo "stato" del gatto è costituito dalle variabili private mood, hungry, energy e dal metodo privato meow(), che il gatto può chiamare ogni volta che vuole, mentre le altre classi non possono.

Ciò che possono fare è definito nei metodi pubblici sleep(), play() e feed(). Ognuno di questi modifica in qualche modo lo stato interno e può invocare meow(). Quindi, viene stabilito un legame tra lo stato privato e i metodi pubblici.

Questo è l'incapsulamento.

Astrazione

L'astrazione può essere intesa come un'estensione naturale dell'incapsulamento.

Nel design orientato agli oggetti, i programmi sono spesso estremamente estesi e oggetti separati comunicano molto tra di loro. Quindi gestire un codebase così esteso per anni – senza cambiamenti strada facendo – è complicato.

L'astrazione è un concetto finalizzato a semplificare questo problema.

Applicare un'astrazione significa che ogni oggetto dovrebbe mettere in mostra solo un meccanismo di alto livello.

Questo meccanismo dovrebbe nascondere i dettagli interni di implementazione, rivelando solamente le operazioni rilevanti per gli altri oggetti.

Pensa a una macchina del caffè. Fa un sacco di roba e produce rumori bizzarri dal suo interno. Ma tutto ciò che devi fare è mettere dentro il caffè e premere un bottone.

Preferibilmente, questo meccanismo dovrebbe essere facile da utilizzare e dovrebbe cambiare di rado. Pensa a un piccolo insieme di metodi pubblici che ogni altra classe può chiamare senza "conoscere" come funzionano.

Un altro esempio pratico di astrazione?
Pensa a come usi il tuo cellulare:

Interagisci con il tuo cellulare usando solamente pochi pulsanti. Cosa accade al suo interno? Non c'è bisogno che tu lo sappia – i dettagli di implementazione sono nascosti. Devi soltanto conoscere una breve lista di azioni.

I cambiamenti nell'implementazione – ad esempio, un aggiornamento del software – raramente influiscono sull'astrazione di cui fai uso.

Ereditarietà

Bene, abbiamo visto come l'incapsulamento e l'astrazione possono aiutarci a sviluppare e mantenere un codebase esteso.

Ma sai qual è un altro problema comune del design della programmazione orientata agli oggetti?

Spesso gli oggetti sono molto simili. Condividono una logica comune ma non sono completamente uguali.

Dunque, come possiamo riutilizzare una logica comune ed estrarre la logica unica in una classe separata? Un modo per farlo è tramite l'ereditarietà.

Questo si traduce nella creazione di una classe (figlia) derivata da un altra classe (genitore), formando una gerarchia.

La classe figlia riutilizza tutti i campi e i metodi della classe genitore (le parti comuni) e può implementarne di propri (parte unica).

Ad esempio:

Se il nostro programma ha bisogno di gestire insegnanti pubblici e privati, ma anche altre persone come studenti, può implementare questa gerarchia di classi.

In questo modo, a ogni classe si aggiunge soltanto ciò che le è necessario riutilizzando la logica comune della classe genitore.

Polimorfismo

Ed eccoci alla parola più complicata! Polimorfismo deriva dal greco e vuol dire "molte forme".

Conosciamo già il potere  dell'ereditarietà e lo sfruttiamo volentieri. Ma ecco che arriva un problema.

Ipotizziamo di avere una classe genitore e poche classi figlie che ereditano proprietà e metodi da questa. A volte potremmo aver bisogno di usare una collezione – ad esempio una lista – che contiene un mix di tutte queste classi. Oppure abbiamo un metodo implementato per la classe genitore – ma vorremmo usarlo anche per i discendenti.

Si può risolvere tutto ciò grazie al polimorfismo.

In parole povere, il polimorfismo fornisce un modo di usare una classe esattamente come il suo genitore, così che non ci sia confusione data dal mix dei vari tipi. Ma ogni classe figlia mantiene i propri metodi tal quali.

Questo avviene tipicamente definendo un'interfaccia (genitore) da riutilizzare. Definisce un gruppo di metodi comuni. Poi, ogni classe figlia implementa la propria versione di questi metodi.

Ogni volta che una collezione (come una lista) o un metodo si aspetta una istanza del genitore (in cui sono definiti i metodi comuni), il linguaggio si occupa di valutare l'implementazione corretta per il metodo comune – indipendentemente da quale figlio gli viene passato.

Dai un'occhiata allo schizzo dell'implementazione delle figure geometriche qui sotto. Riutilizzano un'interfaccia comune per calcolare l'area e il perimetro:

Avere tre figure che ereditano Figure Interface dal genitore, ti permette di creare una lista mista di triangle, circle e rectangle, che puoi trattare come lo stesso tipo di oggetto.

Poi, se questa lista prova a calcolare l'area di un elemento, il metodo corretto viene trovato ed eseguito. Se l'elemento è un triangolo, viene chiamata CalculateSurface() del triangolo. Se è un cerchio, viene chiamata CalculateSurface() del cerchio, e così via.

Se hai una funzione che opera con una figura usando i suoi parametri, non devi definirla tre volte – una volta per il triangolo, una volta per il cerchio e una volta per il rettangolo.

Puoi definirla una volta e accettare Figura come argomento. Se passi un triangolo, un cerchio o un rettangolo – finché implementano CalculateParamter() – il loro tipo non conta.

Spero che questo sia stato d'aiuto. Puoi usare direttamente queste stesse spiegazioni in un colloquio di lavoro.