Metodi, array e primi principi di progettazione: imparare a dividere un problema
Dopo aver imparato a scrivere programmi con variabili, condizioni e cicli, facciamo un passo fondamentale: smettiamo di concentrare tutta la logica dentro il main. In questa lezione impariamo a scomporre un problema, progettare metodi, passare parametri, restituire risultati e lavorare con gli array.
void e differenza tra parametro e argomento.for e enhanced for.1. Dal programma che funziona al programma che si capisce
Nella prima lezione abbiamo costruito programmi molto semplici: variabili, condizioni, cicli e operazioni. È stato corretto partire così, perché prima di organizzare il codice bisogna sapere come funziona.
Ora però compare un problema tipico. Aggiungendo istruzioni, il main tende a diventare sempre più lungo. Il programma può continuare a funzionare, ma diventa difficile da leggere, modificare e verificare.
Una cosa che voglio farvi capire fin da subito è questa: funzionante non significa necessariamente ben progettato. Un programma può produrre il risultato corretto ed essere comunque difficile da mantenere.
Immaginiamo di avere un programma che legge 10 prezzi, calcola la somma, determina il prezzo medio, trova il prezzo più alto, verifica se esiste un prodotto sopra una certa soglia e stampa il riepilogo. Possiamo scrivere tutto nel main, ma presto avremo decine di righe con responsabilità diverse mescolate tra loro.
Il passaggio di oggi è quindi concettuale: dividere un problema grande in problemi più piccoli. In Java lo faremo principalmente attraverso i metodi.
2. Perché servono i metodi?
Un metodo raggruppa istruzioni che realizzano un comportamento specifico. Possiamo chiamarlo quando ci serve, passandogli eventualmente i dati necessari.
2.1 Un primo metodo
Partiamo da un esempio molto semplice:
Abbiamo definito un metodo chiamato saluta. Per eseguirlo dobbiamo chiamarlo:
Un metodo è un blocco di codice che rappresenta un comportamento e può essere richiamato dal programma quando necessario.
La parola void indica che questo metodo non restituisce un valore.
2.2 Parametri e argomenti
Un metodo diventa molto più utile quando può lavorare con dati diversi.
Qui nome è un parametro. Quando chiamiamo il metodo forniamo un argomento:
| Concetto | Esempio | Significato |
|---|---|---|
| Parametro | String nome | Variabile dichiarata nella definizione del metodo. |
| Argomento | "Mario" | Valore concreto passato durante la chiamata. |
Pensate al parametro come a uno spazio vuoto: il metodo dice "mi serve un dato di questo tipo". L'argomento è il dato concreto che inseriamo in quello spazio.
2.3 Valore di ritorno
Molti metodi non devono semplicemente stampare qualcosa. Devono calcolare un risultato e restituirlo.
Il metodo restituisce un int. Possiamo quindi utilizzare il risultato:
Non confondete il restituire un risultato con lo stampare un risultato. Un metodo che calcola dovrebbe, quando possibile, restituire il valore. Sarà il chiamante a decidere se stamparlo, salvarlo, confrontarlo o utilizzarlo in un'altra elaborazione.
2.4 void
Confrontiamo due metodi:
Il primo esegue un'azione e non restituisce un valore. Il secondo produce un dato che può essere riutilizzato.
Quando scrivete un metodo chiedetevi: questo metodo deve fare qualcosa o deve calcolare qualcosa? La risposta aiuta a capire se siamo davanti a un comportamento void oppure a un'operazione che deve restituire un valore.
3. Progettare un buon metodo
3.1 Una responsabilità chiara
Un buon metodo dovrebbe avere una responsabilità comprensibile. Un metodo chiamato:
ci fa già intuire cosa dovrebbe fare.
Un metodo chiamato:
è molto più ambiguo.
3.2 Nomi significativi
Preferiamo:
rispetto a:
Un nome ben scelto riduce il bisogno di commenti. Prima di scrivere un commento per spiegare cosa fa un metodo, chiedetevi se potete migliorare il nome del metodo.
3.3 Metodi troppo grandi
Se un metodo contiene acquisizione dati, validazione, calcolo, salvataggio, stampa e gestione degli errori, probabilmente sta facendo troppe cose.
Non esiste una lunghezza magica oltre la quale un metodo diventa "sbagliato". Il criterio più utile è la responsabilità.
Se domani cambia soltanto la regola con cui calcolo lo sconto, quante parti del programma devo modificare? Un buon progetto cerca di limitare l'impatto delle modifiche.
4. Scope e visibilità delle variabili
Quando utilizziamo metodi dobbiamo capire dove una variabile esiste e dove può essere utilizzata.
La variabile numero appartiene al blocco in cui è stata dichiarata. Non possiamo utilizzarla direttamente fuori da quel blocco.
Quando IntelliJ segnala che una variabile non è visibile, non significa che la variabile "non esiste nel programma". Significa che non esiste in quello scope. La soluzione non è rendere tutto globale: bisogna capire chi deve possedere e ricevere quel dato.
Il passaggio dei dati attraverso i parametri è uno dei meccanismi che ci permette di mantenere il codice organizzato.
5. Gli array
Finora abbiamo lavorato soprattutto con una variabile alla volta. Ma cosa succede se dobbiamo gestire 30 voti, 100 temperature o 500 prezzi?
Creare centinaia di variabili separate non è una soluzione ragionevole. Un array permette di memorizzare più valori dello stesso tipo in una struttura indicizzata.
5.1 Dichiarazione e inizializzazione
Abbiamo un array di int contenente cinque valori.
Possiamo anche specificare la dimensione:
In questo caso abbiamo creato un array con sette elementi inizializzati al valore predefinito del tipo.
Un array è una struttura a dimensione fissa che contiene elementi dello stesso tipo, identificati tramite un indice.
5.2 Indici e accesso agli elementi
Gli array Java utilizzano indici che partono da 0.
Con cinque elementi l'ultimo indice è 4, non 5. L'accesso a voti[5] produce un errore a runtime: ArrayIndexOutOfBoundsException.
5.3 length
Per sapere quanti elementi contiene un array utilizziamo la proprietà length:
Notate la differenza rispetto a un metodo: scriviamo length, senza parentesi.
5.4 Scorrere un array
Il modo più immediato è utilizzare un for:
Quando non ci serve conoscere l'indice possiamo utilizzare l'enhanced for:
| Situazione | Scelta consigliata |
|---|---|
| Mi serve l'indice | for tradizionale |
| Mi serve solo il valore | enhanced for |
| Devo modificare elementi tramite posizione | spesso for tradizionale |
6. Operazioni tipiche sugli array
6.1 Somma e media
Calcoliamo la somma e poi la media:
Qui compare un dettaglio importante: se facciamo la divisione tra interi otteniamo una divisione intera. Quando vogliamo una media decimale dobbiamo prestare attenzione ai tipi coinvolti.
6.2 Minimo e massimo
Per trovare il massimo possiamo iniziare dal primo elemento e confrontare progressivamente gli altri:
Lo stesso principio può essere utilizzato per il minimo:
Non inizializzate sempre il massimo a 0. Se tutti i valori fossero negativi, il risultato sarebbe sbagliato. In generale è più robusto partire da un elemento reale dell'array.
6.3 Ricerca di un elemento
Possiamo cercare se un valore è presente:
Il break ci permette di interrompere la ricerca quando abbiamo già trovato ciò che cercavamo.
7. Decomporre un problema
Adesso uniamo i due concetti principali della lezione: metodi + array.
Immaginiamo di dover sviluppare un programma che riceve una serie di voti e deve:
- calcolare la somma;
- calcolare la media;
- trovare il voto massimo;
- trovare il voto minimo;
- contare quanti voti sono sufficienti.
Un approccio poco organizzato sarebbe inserire tutto nel main. Un approccio più strutturato consiste nel definire una responsabilità per ogni operazione.
Quando vi trovate davanti a 40 righe di codice, non chiedetevi subito come accorciarle. Chiedetevi quali problemi diversi sono nascosti dentro quelle 40 righe.
8. Refactoring: dal codice monolitico ai metodi
Consideriamo una prima versione:
Funziona. Ma possiamo migliorarlo separando i calcoli.
Il main diventa quindi un coordinatore:
Ora possiamo modificare il modo in cui calcoliamo il massimo senza dover cercare quella logica dentro tutto il programma. Inoltre possiamo riutilizzare calcolaMedia() con altri array.
Il refactoring non significa "riscrivere tutto perché il codice non mi piace". Significa migliorare la struttura mantenendo lo stesso comportamento. Questa distinzione diventerà fondamentale nei progetti più grandi.
9. Errori comuni
| Errore | Causa tipica | Come ragionare |
|---|---|---|
| Metodo chiamato con argomenti sbagliati | Numero o tipo dei parametri non corrispondente | Confrontare firma del metodo e chiamata. |
Metodo che dovrebbe restituire un valore ma non usa return | Confusione tra calcolo e stampa | Chiedersi quale risultato deve produrre il metodo. |
| Variabile non visibile | Scope errato | Capire dove la variabile è stata dichiarata. |
ArrayIndexOutOfBoundsException | Indice fuori dai limiti | Ricordare che gli indici partono da 0 e usare length. |
| Media errata | Divisione intera | Controllare i tipi coinvolti nella divisione. |
| Massimo/minimo errato | Valore iniziale scelto male | Partire da un elemento reale dell'array. |
| Metodo enorme | Più responsabilità mescolate | Individuare blocchi logici separabili. |
Non abbiate paura di vedere un errore. In questa fase l'errore è materiale didattico: ci interessa imparare a leggere il problema e a formulare una diagnosi.
10. Caso d'uso professionale: statistiche sugli ordini
Immaginiamo un piccolo sistema che deve analizzare gli importi di una serie di ordini:
Vogliamo ottenere:
- totale degli ordini;
- valore medio;
- ordine massimo;
- numero di ordini superiori a 100 euro.
Una possibile organizzazione è:
Il programma principale può quindi essere molto più leggibile:
Se domani il responsabile chiede di cambiare la soglia da 100 a 250 euro, quanto codice dobbiamo modificare? Un buon progetto rende le modifiche localizzate e comprensibili.
11. Verifica ragionata
🔬 Prova di comprensione
Scenario: un'azienda registra le temperature rilevate da un sensore durante una giornata:
Il programma deve:
- calcolare la temperatura media;
- trovare la temperatura massima;
- contare quante rilevazioni superano i 22 °C;
- stampare i risultati.
Prima del codice: quali metodi creeresti? Quali parametri servono? Quale valore dovrebbe restituire ciascun metodo?
La soluzione può essere diversa. Quello che ci interessa valutare è il ragionamento: responsabilità chiare, parametri corretti, valori di ritorno coerenti e gestione dell'array senza errori di indice.
12. Riepilogo e concetti chiave
Il salto di qualità non avviene quando scriviamo più codice. Avviene quando riusciamo a scrivere codice che un'altra persona può leggere, capire e modificare.
13. Conclusione e ponte verso il laboratorio
In questa lezione abbiamo introdotto uno dei passaggi più importanti dell'intero corso: la decomposizione del problema.
Abbiamo visto come i metodi permettano di isolare responsabilità, come i parametri consentano di fornire dati, come i valori di ritorno permettano di riutilizzare i risultati e come gli array consentano di lavorare con insiemi di valori.
Il laboratorio porterà questi concetti su esercizi progressivi: prima piccoli metodi, poi operazioni sugli array, quindi statistiche, ricerca, minimo e massimo e infine il refactoring di un programma inizialmente monolitico.
Non cercate di memorizzare una "formula" per scrivere i metodi. Abituatevi a riconoscere le responsabilità. Quando sapete cosa deve fare una parte del programma, diventa molto più semplice decidere come chiamarla e quali dati passarle.
💻 Laboratorio della Lezione 02
Nel laboratorio lavoreremo con metodi, parametri, valori di ritorno e array. Realizzeremo esercizi progressivi su somma, media, minimo, massimo, ricerca e validazione, fino al refactoring di un programma monolitico.
Laboratorio Lezione 02 →Metodi, array, statistiche e refactoring📚 Prossimo passo — OOP: classi, oggetti e incapsulamento
Nella prossima lezione inizieremo a modellare concetti del mondo reale attraverso classi e oggetti. Entreremo in attributi, metodi, costruttori, this, static, final, modificatori di accesso e incapsulamento.

