Cos'è l'incapsulamento?

Immagina che un'app bancaria memorizzi il saldo di ogni conto in una semplice variabile. Qualsiasi riga in qualsiasi punto del programma può scrivere account.balance = -500, e niente la ferma. Quando in produzione compare un saldo negativo, devi cercare in tutto il codice ogni punto che lo ha toccato. L'incapsulamento risolve il problema: il saldo può cambiare solo tramite pochi metodi, e quei metodi fanno rispettare le regole, per esempio che un prelievo non superi mai il saldo.

Come funziona l'incapsulamento

L'incapsulamento unisce due idee:

1. Raggruppare. I dati (il saldo) e il codice che lavora su di essi (deposito, prelievo) vivono nella stessa classe.
2. Nascondere. Il resto del codice vede solo l'interfaccia pubblica della classe. I dati dietro di essa sono interni, quindi possono cambiare solo nei modi che la classe permette.

La regola che la classe protegge si chiama invariante: qui, "il saldo non è mai negativo". Siccome ogni modifica passa per i metodi della classe, l'invariante vale qualunque cosa faccia il resto del programma.

class BankAccount:
    def __init__(self):
        self._balance = 0  # internal: change it only through the methods

    @property
    def balance(self):     # read-only from outside
        return self._balance

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("not enough money")
        self._balance -= amount

acct = BankAccount()
acct.deposit(100)
acct.withdraw(30)
print(acct.balance)
try:
    acct.withdraw(500)
except ValueError as err:
    print("refused:", err)

70
refused: not enough money

Il codice esterno può leggere acct.balance, ma la proprietà non ha un setter, quindi acct.balance = 1000 solleva un AttributeError. Se il saldo risulta sbagliato, ci sono esattamente due metodi da controllare.

L'incapsulamento in Python

Python non ha una parola chiave private. Si affida a convenzioni sui nomi che chiunque programmi in Python conosce:

• name: pubblico, parte dell'interfaccia.
• _name: interno. Niente ti impedisce di leggerlo, ma il trattino basso iniziale dice "non dipendere da questo".
• __name: Python lo rinomina dentro la classe (name mangling), così una sottoclasse non può sovrascriverlo per sbaglio.
• @property: trasforma un metodo in qualcosa che si legge come un attributo, così puoi aggiungere controlli in seguito senza cambiare il codice che lo chiama.

class Counter:
    def __init__(self):
        self._count = 0      # one underscore: "internal, please don't touch"
        self.__secret = 42   # two underscores: the name gets mangled

c = Counter()
print(c._count)                   # still readable: it is only a convention
print(hasattr(c, "__secret"))     # the plain name does not exist
print(c._Counter__secret)         # Python renamed it to _Counter__secret

0
False
42

Il name mangling evita gli incidenti, non l'accesso: il nome modificato funziona comunque. Python si fida del fatto che chi programma rispetti il trattino basso. In pratica la maggior parte del codice Python usa un solo trattino basso più @property, e riserva il doppio trattino basso alle classi pensate per essere estese. Trovi altro su come scrivere classi nella documentazione sulle classi Python.

L'incapsulamento in Java, C++ e JavaScript

Altri linguaggi impongono l'occultamento. In Java, un campo private si può usare solo dentro la sua classe:

public class BankAccount {
    private int balance;  // hidden from every other class

    public int getBalance() { return balance; }

    public void withdraw(int amount) {
        if (amount > balance) throw new IllegalArgumentException("not enough money");
        balance -= amount;
    }
}

Scrivere account.balance = 1000; in un'altra classe non compila: javac segnala balance has private access in BankAccount.

C++ rende privati per impostazione predefinita i membri di una class e pubblici quelli di una struct. I campi privati # di JavaScript, aggiunti in ES2022, non si possono leggere in nessun modo da fuori della classe. La documentazione li tratta uno per uno: modificatori di accesso in Java, specificatori di accesso in C++ e campi privati in JavaScript.

Perché l'incapsulamento è importante

• Le regole stanno in un solo posto. Il controllo "nessun prelievo oltre il saldo" si scrive una volta, dentro withdraw, invece che prima di ogni prelievo del programma.
• Puoi cambiare l'interno liberamente. Se decidi di memorizzare il denaro in centesimi interi invece che come float, cambia solo la classe. Il codice che chiama deposit(100) continua a funzionare.
• Debug più facile. Quando un valore è sbagliato, i sospetti sono i pochi metodi che possono modificarlo, non ogni riga del programma.
• Meno da imparare e da testare. Una classe con tre metodi pubblici si può capire e testare attraverso quei tre metodi.

L'incapsulamento funziona anche sopra il livello delle classi. Un modulo che espone due funzioni e tiene interne dieci funzioni di supporto è incapsulato allo stesso modo, e così un sistema operativo che permette ai programmi di aprire file solo tramite chiamate di sistema.

Spesso lo si confonde con l'astrazione. L'astrazione decide cosa offre l'interfaccia; l'incapsulamento protegge i dati che stanno dietro. La pagina sull'astrazione ha un confronto completo tra le due. Insieme al polimorfismo e all'ereditarietà, sono i quattro pilastri della programmazione a oggetti.

Errori comuni

• Un getter e un setter per ogni campo. Un setBalance che accetta qualsiasi numero non protegge niente. Offri le operazioni di cui l'oggetto ha bisogno (withdraw), non l'accesso diretto a ogni campo.
• Restituire oggetti interni. Un metodo che restituisce self._items consegna a chi lo chiama la lista vera, che ora può modificare. Restituisci invece una copia o una tupla.
• Scambiare private per sicurezza. I modificatori di accesso prevengono gli errori, non gli attacchi. Il codice Java può leggere i campi privati tramite reflection, e il codice Python può leggere _name direttamente. Password e chiavi hanno bisogno di una protezione vera, come hashing e crittografia.

Cosa leggere dopo

Leggi ora astrazione, che spiega la differenza tra le due idee, poi polimorfismo. Il corso Python costruisce le classi passo dopo passo, e il corso Java mostra l'incapsulamento imposto dal compilatore.