16 min di lettura
Pubblicato il 16 Novembre 2026 · Aggiornato il 16 Novembre 2026
GUIDE · Java e strumenti per lo sviluppo • UFS 04 • Lezione 02
✍ Autore: Docente UFS 04

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.

☕ Java JDK 17/21 🛠 IntelliJ IDEA
OBIETTIVI DI APPRENDIMENTO
✓Comprendere perché un programma deve essere suddiviso in parti più piccole e comprensibili.
✓Definire e utilizzare metodi con e senza parametri.
✓Comprendere valori di ritorno, void e differenza tra parametro e argomento.
✓Comprendere lo scope delle variabili e riconoscere gli errori tipici di visibilità.
✓Utilizzare array monodimensionali e accedere ai loro elementi tramite indice.
✓Scorrere array con for e enhanced for.
✓Realizzare operazioni di ricerca, minimo, massimo e statistiche elementari.
✓Trasformare codice monolitico in codice organizzato tramite metodi e responsabilità più chiare.
✓Iniziare a ragionare sul codice in termini di leggibilità, riuso e progettazione.

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.

💬 Tip del docente

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.

🎯 Situazione tipica

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:

JAVA
public static void saluta() { System.out.println("Benvenuto al corso UFS 04"); }

Abbiamo definito un metodo chiamato saluta. Per eseguirlo dobbiamo chiamarlo:

JAVA
public static void main(String[] args) { saluta(); }
📌 Definizione

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.

JAVA
public static void saluta(String nome) { System.out.println("Ciao " + nome); }

Qui nome è un parametro. Quando chiamiamo il metodo forniamo un argomento:

JAVA
saluta("Mario"); saluta("Luca"); saluta("Anna");
ConcettoEsempioSignificato
ParametroString nomeVariabile dichiarata nella definizione del metodo.
Argomento"Mario"Valore concreto passato durante la chiamata.
💬 Frase del docente

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.

JAVA
public static int somma(int a, int b) { return a + b; }

Il metodo restituisce un int. Possiamo quindi utilizzare il risultato:

JAVA
int risultato = somma(10, 20);System.out.println(risultato);
⚠ Errore comune

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:

JAVA
public static void stampaTotale(double totale) { System.out.println("Totale: " + totale); }public static double calcolaTotale(double prezzo, int quantita) { return prezzo * quantita; }

Il primo esegue un'azione e non restituisce un valore. Il secondo produce un dato che può essere riutilizzato.

💬 Tip del docente

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:

JAVA
calcolaMedia()

ci fa già intuire cosa dovrebbe fare.

Un metodo chiamato:

JAVA
gestisciDati()

è molto più ambiguo.

3.2 Nomi significativi

Preferiamo:

JAVA
calcolaPrezzoFinale() trovaMassimo() cercaProdotto() validaQuantita()

rispetto a:

JAVA
f1() doIt() process() gestisci()
💬 Tip del docente

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à.

🎯 Domanda professionale

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.

JAVA
public static void esempio() { int numero = 10;System.out.println(numero); }

La variabile numero appartiene al blocco in cui è stata dichiarata. Non possiamo utilizzarla direttamente fuori da quel blocco.

JAVA
public static void esempio() { int numero = 10; }public static void main(String[] args) { System.out.println(numero); // ERRORE }
⚠ Errore comune

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

JAVA
int[] voti = {24, 28, 30, 18, 27};

Abbiamo un array di int contenente cinque valori.

Possiamo anche specificare la dimensione:

JAVA
int[] temperature = new int[7];

In questo caso abbiamo creato un array con sette elementi inizializzati al valore predefinito del tipo.

📌 Definizione

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.

JAVA
int[] voti = {24, 28, 30, 18, 27};System.out.println(voti[0]); // 24 System.out.println(voti[1]); // 28 System.out.println(voti[4]); // 27
⚠ Errore comune

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:

JAVA
int[] voti = {24, 28, 30, 18, 27};System.out.println(voti.length); // 5

Notate la differenza rispetto a un metodo: scriviamo length, senza parentesi.

5.4 Scorrere un array

Il modo più immediato è utilizzare un for:

JAVA
int[] voti = {24, 28, 30, 18, 27};for (int i = 0; i < voti.length; i++) { System.out.println(voti[i]); }

Quando non ci serve conoscere l'indice possiamo utilizzare l'enhanced for:

JAVA
for (int voto : voti) { System.out.println(voto); }
SituazioneScelta consigliata
Mi serve l'indicefor tradizionale
Mi serve solo il valoreenhanced for
Devo modificare elementi tramite posizionespesso for tradizionale

6. Operazioni tipiche sugli array

6.1 Somma e media

Calcoliamo la somma e poi la media:

JAVA
int[] voti = {24, 28, 30, 18, 27};int somma = 0;for (int voto : voti) { somma += voto; }double media = (double) somma / voti.length;System.out.println("Somma: " + somma); System.out.println("Media: " + media);
💬 Tip del docente

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:

JAVA
int[] valori = {24, 28, 30, 18, 27};int massimo = valori[0];for (int valore : valori) { if (valore > massimo) { massimo = valore; } }System.out.println("Massimo: " + massimo);

Lo stesso principio può essere utilizzato per il minimo:

JAVA
int minimo = valori[0];for (int valore : valori) { if (valore < minimo) { minimo = valore; } }
⚠ Errore comune

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:

JAVA
int[] valori = {12, 25, 31, 18, 42}; int cercato = 31;boolean trovato = false;for (int valore : valori) { if (valore == cercato) { trovato = true; break; } }System.out.println("Trovato: " + trovato);

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:

  1. calcolare la somma;
  2. calcolare la media;
  3. trovare il voto massimo;
  4. trovare il voto minimo;
  5. 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.

Problema: analizzare voti calcolaSomma() un solo compito calcolaMedia() un solo compito trovaMassimo() un solo compito contaSufficienti() un solo compito Il main coordina; i metodi svolgono responsabilità specifiche.
💬 Frase del docente

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:

JAVA
public static void main(String[] args) {int[] voti = {24, 28, 30, 18, 27};int somma = 0; for (int voto : voti) { somma += voto; }double media = (double) somma / voti.length;int massimo = voti[0]; for (int voto : voti) { if (voto > massimo) { massimo = voto; } }System.out.println("Media: " + media); System.out.println("Massimo: " + massimo); }

Funziona. Ma possiamo migliorarlo separando i calcoli.

JAVA
public static int calcolaSomma(int[] valori) { int somma = 0;for (int valore : valori) { somma += valore; }return somma; }public static double calcolaMedia(int[] valori) { int somma = calcolaSomma(valori); return (double) somma / valori.length; }public static int trovaMassimo(int[] valori) { int massimo = valori[0];for (int valore : valori) { if (valore > massimo) { massimo = valore; } }return massimo; }

Il main diventa quindi un coordinatore:

JAVA
public static void main(String[] args) {int[] voti = {24, 28, 30, 18, 27};double media = calcolaMedia(voti); int massimo = trovaMassimo(voti);System.out.println("Media: " + media); System.out.println("Massimo: " + massimo); }
🎯 Perché è un miglioramento?

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.

💬 Tip del docente

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

ErroreCausa tipicaCome ragionare
Metodo chiamato con argomenti sbagliatiNumero o tipo dei parametri non corrispondenteConfrontare firma del metodo e chiamata.
Metodo che dovrebbe restituire un valore ma non usa returnConfusione tra calcolo e stampaChiedersi quale risultato deve produrre il metodo.
Variabile non visibileScope erratoCapire dove la variabile è stata dichiarata.
ArrayIndexOutOfBoundsExceptionIndice fuori dai limitiRicordare che gli indici partono da 0 e usare length.
Media errataDivisione interaControllare i tipi coinvolti nella divisione.
Massimo/minimo erratoValore iniziale scelto malePartire da un elemento reale dell'array.
Metodo enormePiù responsabilità mescolateIndividuare blocchi logici separabili.
💬 Tip del docente

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:

JAVA
double[] ordini = { 120.50, 80.00, 450.75, 32.90, 210.00 };

Vogliamo ottenere:

  • totale degli ordini;
  • valore medio;
  • ordine massimo;
  • numero di ordini superiori a 100 euro.

Una possibile organizzazione è:

JAVA
public static double calcolaTotale(double[] ordini) { double totale = 0;for (double ordine : ordini) { totale += ordine; }return totale; }public static double calcolaMedia(double[] ordini) { return calcolaTotale(ordini) / ordini.length; }public static double trovaMassimo(double[] ordini) { double massimo = ordini[0];for (double ordine : ordini) { if (ordine > massimo) { massimo = ordine; } }return massimo; }public static int contaOrdiniSopraSoglia(double[] ordini, double soglia) { int conteggio = 0;for (double ordine : ordini) { if (ordine > soglia) { conteggio++; } }return conteggio; }

Il programma principale può quindi essere molto più leggibile:

JAVA
public static void main(String[] args) {double[] ordini = { 120.50, 80.00, 450.75, 32.90, 210.00 };double totale = calcolaTotale(ordini); double media = calcolaMedia(ordini); double massimo = trovaMassimo(ordini); int sopraSoglia = contaOrdiniSopraSoglia(ordini, 100);System.out.println("Totale: " + totale); System.out.println("Media: " + media); System.out.println("Massimo: " + massimo); System.out.println("Ordini sopra 100 €: " + sopraSoglia); }
🎯 Domanda professionale

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:

JAVA
double[] temperature = { 18.5, 19.2, 21.0, 23.4, 24.1, 22.8, 20.5 };

Il programma deve:

  1. calcolare la temperatura media;
  2. trovare la temperatura massima;
  3. contare quante rilevazioni superano i 22 °C;
  4. stampare i risultati.

Prima del codice: quali metodi creeresti? Quali parametri servono? Quale valore dovrebbe restituire ciascun metodo?

✅ Una possibile soluzione ragionata
JAVA
public static double calcolaMedia(double[] valori) { double somma = 0;for (double valore : valori) { somma += valore; }return somma / valori.length; }public static double trovaMassimo(double[] valori) { double massimo = valori[0];for (double valore : valori) { if (valore > massimo) { massimo = valore; } }return massimo; }public static int contaSopraSoglia(double[] valori, double soglia) { int conteggio = 0;for (double valore : valori) { if (valore > soglia) { conteggio++; } }return conteggio; }

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.

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.

💬 Tip del docente

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.

✦ Trasparenza AI: uso strumenti AI per bozze, schemi e immagini. Ogni contenuto lo revisiono, testo i comandi in laboratorio e lo riscrivo con la mia esperienza in classe prima di pubblicarlo. La responsabilità di quello che leggi è mia.
Mario Giagnotti
AUTORE
Mario Giagnotti
Ingegnere Elettronico e docente di Informatica.