Incapsulamento

"Ciao, Amigo! Voglio dedicare la lezione di oggi all'incapsulamento . Hai già un'idea generale di cosa sia."

Quindi quali sono i vantaggi dell'incapsulamento? Ce ne sono molti, ma ne indicherò quattro che sono, a mio avviso, i più importanti:

1) Stato interno valido.

I programmi hanno spesso diverse classi che interagiscono con lo stesso oggetto. Interagendo simultaneamente con i dati interni dell'oggetto, possono violare l'integrità dei dati dell'oggetto, causando l'interruzione del corretto funzionamento dell'oggetto.

Quindi l'oggetto deve tenere traccia di eventuali modifiche ai suoi dati interni o, meglio ancora, dovrebbe essere lui a apportare tali modifiche.

Se non vogliamo che una variabile di classe venga modificata da altre classi, la dichiariamo private , il che significa che solo i metodi di quella classe possono accedervi. Se vogliamo che le variabili siano di sola lettura per altre classi, allora aggiungiamo public getter a queste variabili.

Ad esempio, potremmo volere che tutti sappiano quanti elementi ci sono nella nostra collezione, ma nessuno dovrebbe essere in grado di cambiarli senza il nostro permesso. In questo caso dichiariamo una variabile private int count e un metodo public getCount() .

Un corretto incapsulamento garantisce che altre classi non possano accedere direttamente ai dati interni della nostra classe e, di conseguenza, non possano modificarli senza che noi siamo in grado di controllare le loro azioni. Devono chiamare metodi sulla classe che contiene le variabili che verranno modificate.

È meglio presumere che gli altri programmatori useranno sempre le tue classi nel modo più conveniente per loro, non nel modo che sarebbe più sicuro per te (o la tua classe). Questa è una fonte di bug e un modo per prevenirli.

2) Controllo dei parametri.

A volte devi controllare i parametri passati nei metodi della tua classe. Ad esempio, supponiamo di avere una classe che rappresenta una "persona" e di poterne specificare la data di nascita. Dovremmo verificare che tutti i dati passati corrispondano alla logica del programma e alla logica della classe. Ad esempio, non esiste il 13° mese, il 30 febbraio, ecc.

"Perché qualcuno dovrebbe indicare una data di nascita del 30 febbraio?"

"Beh, prima di tutto, potrebbe essere il risultato di un errore di inserimento dei dati."

In secondo luogo, prima che un programma funzioni come un orologio, potrebbe avere molti bug. Ad esempio, potrebbe accadere qualcosa del genere.

Un programmatore scrive il codice che determina chi compie gli anni dopodomani. Diciamo che oggi è il 3 marzo. Il programma aggiunge 2 alla data corrente e trova tutti i nati il ​​5 marzo. Fin qui tutto bene.

Ma quando arriva il 30 marzo, il programma non trova nessuno, dato che non c'è il 32 marzo. I programmi sono molto meno buggati quando i metodi eseguono il controllo dei parametri."

"Ricordo che quando abbiamo studiato ArrayList ho guardato il suo codice e c'erano controlli nei metodi get e set per garantire che il parametro index fosse maggiore o uguale a zero e minore della lunghezza dell'array. Il codice genererebbe un eccezione se l'array non ha un elemento corrispondente all'indice.

"Sì, questo è il classico controllo dell'input. "

3) Meno bug quando si cambia codice all'interno delle classi.

Supponiamo di aver scritto una lezione davvero utile come parte di un enorme progetto. A tutti piace così tanto che altri programmatori hanno iniziato a usarlo in centinaia di posti nel proprio codice.

La lezione si è rivelata così utile che hai deciso di migliorarla. Ma se ti sbarazzi di uno qualsiasi dei metodi della classe, il codice di dozzine di altri programmatori non verrà più compilato. Dovrebbero riscrivere rapidamente il loro codice. E più riscrittura avviene, più opportunità ci sono per i bug. Se rompi regolarmente la build, sarai odiato.

Ma se cambiamo i metodi contrassegnati come privati, sappiamo che questi metodi non sono chiamati dal codice di nessun altro da nessuna parte. Possiamo riscriverli e modificare il numero e il tipo di parametri e il codice dipendente funzionerà ancora. O almeno verrà comunque compilato.

4) Definiamo come altri oggetti interagiranno con il nostro oggetto.

Possiamo limitare le azioni che possono essere intraprese sul nostro oggetto. Ad esempio, potremmo voler creare solo un'istanza di una classe, anche se viene creata in più punti contemporaneamente nel progetto. E possiamo ottenere questo risultato usando l'incapsulamento.

L'incapsulamento ci consente di imporre ulteriori restrizioni che potrebbero trasformarsi in ulteriori vantaggi . Ad esempio, la classe String è implementata come oggetto immutabile . Un'istanza della classe String non può essere modificata tra la sua creazione e la sua distruzione. Tutti i metodi della classe String (remove, substring, ...) restituiscono una nuova stringa e non modificano in alcun modo l'oggetto su cui sono chiamati.

"Santo cielo. Quindi è così."

"L'incapsulamento è intrigante."

"Sono d'accordo."