Classi, oggetti e incapsulamento
Dalla programmazione procedurale alla programmazione a oggetti: modellare entità reali attraverso stato, comportamento e responsabilità.
Obiettivi della lezione
- Comprendere il passaggio dalla programmazione procedurale alla programmazione a oggetti.
- Distinguere classe, oggetto, attributo, metodo e stato.
- Definire classi Java e creare oggetti con
new. - Utilizzare costruttori e
this. - Comprendere istanza e
static. - Utilizzare
finalper dati non riassegnabili. - Introdurre l'incapsulamento con
private, getter e setter ragionati. - Modellare un problema professionale con una classe.
- Usare debugger e AI per diagnosticare problemi e verificare le soluzioni.
Indice
1. Perché passare agli oggetti?
Nelle prime lezioni abbiamo imparato variabili, condizioni, cicli, metodi e array. Quando il programma cresce, però, dati e operazioni che appartengono alla stessa entità possono finire sparsi in parti diverse del codice.
Pensiamo a un'applicazione aziendale che gestisce prodotti, clienti, ordini o macchine industriali. Per ogni entità abbiamo informazioni da conservare e operazioni da eseguire.
codice, descrizione, prezzo
applicaSconto(), prezzoFinale()
codice, cliente, totale, stato
aggiungiImporto(), conferma()
codice, temperatura, stato
avvia(), arresta(), diagnostica()
Parto da una domanda concreta: “Quali informazioni devo conoscere e quali operazioni posso fare su questa cosa?”. La risposta ci porta naturalmente verso una classe.
La programmazione a oggetti permette quindi di costruire modelli software più vicini al problema che stiamo risolvendo.
2. Classe e oggetto
Oggetto: è un'istanza concreta di una classe, creata durante l'esecuzione.
modello
creazione
istanza
p1 e p2 sono due oggetti distinti della stessa classe.
Classe e oggetto non sono sinonimi: la classe descrive il modello, l'oggetto è una specifica istanza.
3. Attributi e stato
Gli attributi rappresentano le caratteristiche conservate nell'oggetto. L'insieme dei loro valori rappresenta lo stato dell'oggetto in un determinato momento.
| Oggetto | codice | temperatura | accesa |
|---|---|---|---|
| macchina1 | M01 | 42.5 | true |
| macchina2 | M02 | 27.8 | false |
4. Metodi e comportamento
Una classe non dovrebbe essere soltanto un contenitore di variabili: deve anche descrivere ciò che l'entità sa fare.
Un metodo può anche ricevere parametri e restituire un risultato:
Un buon nome racconta l'intenzione:
avvia(), conferma(), calcolaTotale(). Il codice professionale deve essere comprensibile anche a chi lo leggerà dopo di noi.5. Costruttori
Un costruttore permette di creare un oggetto già inizializzato con i dati necessari.
Quando definiamo un costruttore con parametri, non dobbiamo assumere che Java continui a fornire automaticamente anche quello senza parametri.
6. La parola chiave this
this indica l'oggetto corrente. È particolarmente utile quando parametro e attributo hanno lo stesso nome.
La lettura mentale è: “nell'oggetto corrente, assegna all'attributo codice il valore ricevuto dal parametro”.
codice = codice; assegna il parametro a sé stesso; non equivale a this.codice = codice;.7. Creare e utilizzare gli oggetti
Tipo variabile = new Tipo(argomenti);Prodottoprodottoistanza creata con
newChiederei: “Se creo
p1 e p2, quante variabili ho? Quanti oggetti?”. È un modo semplice per verificare il modello mentale.8. Istanza e static
Un membro di istanza appartiene al singolo oggetto. Un membro static è associato alla classe.
| Elemento | Appartiene a | Esempio |
|---|---|---|
| Istanza | singolo oggetto | prodotto.prezzo |
static | classe | Prodotto.numeroProdotti |
Non usare
static come scorciatoia. Chiediti: “Questo dato appartiene a ogni oggetto oppure alla classe?”9. final e costanti
final impedisce la riassegnazione dopo l'inizializzazione.
Una costante condivisa può essere definita con static final:
La combinazione è tipica quando il valore appartiene concettualmente alla classe e non deve essere modificato.
10. Incapsulamento
Se tutti gli attributi sono pubblici, qualsiasi parte del programma può modificarli senza controllo. Questo può portare l'oggetto in uno stato non valido.
Con private proteggiamo lo stato e controlliamo le modifiche attraverso i metodi della classe.
Getter e setter: non automatismi
Getter e setter sono strumenti. Non è necessario esporre indiscriminatamente ogni attributo. Possiamo esporre direttamente un'operazione che rappresenta una regola del dominio.
Non insegnerei “private + getter + setter” come una formula. Chiederei: “Quale regola voglio proteggere?”. L'incapsulamento ha valore quando protegge l'integrità dell'oggetto.
11. Caso professionale: gestione di un ordine
Immaginiamo una piccola applicazione aziendale. Un ordine ha codice, cliente, totale e stato.
Regole: il codice non cambia; non si aggiungono importi negativi; un ordine vuoto non si conferma; un ordine confermato non si modifica.
codice, cliente, totale, confermato
aggiungi importo, conferma
validazione e transizione di stato
12. Errori comuni
| Errore | Problema | Ragionamento corretto |
|---|---|---|
| Confondere classe e oggetto | Modello mentale errato | Classe = definizione; oggetto = istanza |
Attributi sempre public | Stato modificabile senza controllo | Proteggere lo stato quando necessario |
Dimenticare this | Parametro e attributo confusi | this.x indica l'attributo corrente |
Usare static ovunque | Si perde la distinzione tra classe e istanza | Chiedersi a chi appartiene il dato |
| Getter/setter automatici per tutto | Le regole possono essere aggirate | Esporre operazioni significative |
| Classe con troppe responsabilità | Codice difficile da mantenere | Separare responsabilità quando necessario |
Il percorso corretto è: problema → entità → stato → comportamento → regole → codice.
13. Debugging e troubleshooting con AI
Con l'OOP possono comparire errori di stato, costruttori non corretti, accessi non consentiti, uso improprio di static e comportamenti inattesi.
Un assistente AI può aiutare, ma il prompt deve descrivere il problema e non limitarsi a “sistemare il codice”.
La risposta dell'AI non dimostra che il codice sia corretto. Compilare, eseguire, testare e confrontare con il requisito rimane responsabilità dello sviluppatore.
14. Verifica ragionata
Domande concettuali
- Differenza tra classe e oggetto?
- Che cosa rappresenta lo stato?
- Perché utilizziamo un costruttore?
- Che cosa indica
this? - Differenza tra membro di istanza e
static? - Quando è utile
final? - Perché usare
private? - Perché un setter può contenere validazioni?
Domande professionali
- Quale regola del dominio deve proteggere la classe?
- Quali dati appartengono all'oggetto e quali alla classe?
- Quali operazioni dovrebbe poter fare il codice esterno?
- Come capisci se una classe ha troppe responsabilità?
- Come verifichi una soluzione proposta dall'AI?
private o static, ma saper motivare perché usarli.15. Riepilogo e ponte al laboratorio
La lezione introduce il passaggio dalla semplice scrittura di istruzioni alla costruzione di modelli software. Nel laboratorio gli studenti creeranno classi, istanze, costruttori, metodi, attributi privati, getter/setter mirati, membri statici e costanti, fino a modellare un piccolo scenario professionale.
Non mi interessa ancora che lo studente sappia progettare un sistema complesso. Mi interessa che sviluppi il riflesso professionale: prima capisco cosa sto modellando, poi decido quali responsabilità affidare alla classe e solo dopo scrivo il codice.
💻 Laboratorio della Lezione 03
Nel laboratorio lavoreremo con classi, oggetti, costruttori, metodi e attributi. Realizzeremo esercizi progressivi su creazione di istanze, utilizzo di metodi e gestione dello stato, fino a modellare un piccolo scenario professionale.
Laboratorio Lezione 03 →Classi, oggetti e costruttori
