Metodi in Java
I metodi sono blocchi di codice riutilizzabili che eseguono compiti specifici. Permettono di organizzare il codice, evitare duplicazioni e rendere i programmi più leggibili e manutenibili.
Cosa Imparerai
- Definire e chiamare metodi
- Parametri e valori di ritorno
- Overloading dei metodi
- Passaggio per valore vs riferimento
- Array monodimensionali e multidimensionali
- Operazioni comuni sugli array
Anatomia di un Metodo
Struttura Base
// Sintassi generale
modificatori tipoRitorno nomeMetodo(parametri) {
// corpo del metodo
return valore; // se non void
}
// Esempio concreto
public static double calcolaMedia(int[] voti) {
int somma = 0;
for (int voto : voti) {
somma += voto;
}
return (double) somma / voti.length;
}Componenti di un Metodo
| Componente | Descrizione | Esempio |
|---|---|---|
| Modificatori | Visibilità e comportamento | public, private, static |
| Tipo di ritorno | Tipo del valore restituito | int, String, void |
| Nome | Identificatore del metodo | calcolaMedia, stampaVoti |
| Parametri | Input del metodo | (int[] voti, int soglia) |
Metodi void vs con Ritorno
Tipi di Metodo
// Metodo void: non restituisce nulla
public static void stampaIntestazione() {
System.out.println("╔═══════════════════════════╗");
System.out.println("║ REGISTRO SCOLASTICO ║");
System.out.println("╚═══════════════════════════╝");
}
// Metodo con ritorno: restituisce un valore
public static boolean isPromosso(double media) {
return media >= 6.0;
}
// Metodo con ritorno String
public static String getGiudizio(int voto) {
if (voto >= 9) return "Eccellente";
if (voto >= 7) return "Buono";
if (voto >= 6) return "Sufficiente";
return "Insufficiente";
}Parametri dei Metodi
Passaggio Parametri
// Parametri singoli
public static int somma(int a, int b) {
return a + b;
}
// Parametri multipli dello stesso tipo
public static double calcolaMediaPonderata(int voto1, int peso1, int voto2, int peso2) {
return (double)(voto1 * peso1 + voto2 * peso2) / (peso1 + peso2);
}
// Parametri varargs (numero variabile)
public static int sommaVoti(int... voti) {
int somma = 0;
for (int voto : voti) {
somma += voto;
}
return somma;
}
// Utilizzo varargs
int totale1 = sommaVoti(7, 8, 6); // 21
int totale2 = sommaVoti(9, 8, 7, 6, 8, 9); // 47Overloading dei Metodi
L'overloading permette di definire più metodi con lo stesso nome ma parametri diversi (numero, tipo o ordine).
Overloading
public class CalcolatoreVoti {
// Calcola media di 2 voti
public static double media(int v1, int v2) {
return (v1 + v2) / 2.0;
}
// Calcola media di 3 voti
public static double media(int v1, int v2, int v3) {
return (v1 + v2 + v3) / 3.0;
}
// Calcola media di un array
public static double media(int[] voti) {
int somma = 0;
for (int v : voti) somma += v;
return (double) somma / voti.length;
}
// Calcola media con pesi
public static double media(int[] voti, double[] pesi) {
double sommaPonderata = 0;
double sommaPesi = 0;
for (int i = 0; i < voti.length; i++) {
sommaPonderata += voti[i] * pesi[i];
sommaPesi += pesi[i];
}
return sommaPonderata / sommaPesi;
}
}
// Utilizzo - il compilatore sceglie il metodo giusto
double m1 = CalcolatoreVoti.media(7, 8); // 7.5
double m2 = CalcolatoreVoti.media(7, 8, 9); // 8.0
double m3 = CalcolatoreVoti.media(new int[]{7,8,9}); // 8.0Passaggio per Valore
In Java, tutti i parametri sono passati per valore. Questo significa che il metodo riceve una copia del valore.
Passaggio per Valore - Primitivi
public static void incrementaVoto(int voto) {
voto++; // modifica la copia locale
System.out.println("Dentro metodo: " + voto);
}
public static void main(String[] args) {
int mioVoto = 7;
incrementaVoto(mioVoto);
System.out.println("Dopo chiamata: " + mioVoto); // Ancora 7!
}
// Output:
// Dentro metodo: 8
// Dopo chiamata: 7
Passaggio per Valore - Array (Riferimento)
// Gli array passano il riferimento (ma sempre per valore!)
public static void incrementaTuttiVoti(int[] voti) {
for (int i = 0; i < voti.length; i++) {
voti[i]++; // modifica l'array originale!
}
}
public static void main(String[] args) {
int[] classeVoti = {6, 7, 8};
incrementaTuttiVoti(classeVoti);
// Ora classeVoti = {7, 8, 9} - l'array originale e stato modificato!
}Primitivi vs Riferimenti
- Primitivi: Il metodo lavora su una copia, l'originale non cambia
- Array/Oggetti: Il metodo riceve una copia del riferimento, quindi può modificare l'oggetto originale
Array in Java
Un array è una struttura dati che memorizza elementi dello stesso tipo in posizioni contigue di memoria, accessibili tramite indice.
Dichiarazione e Inizializzazione
Creare Array
// Dichiarazione e allocazione separati
int[] voti; // dichiarazione
voti = new int[5]; // allocazione (5 elementi inizializzati a 0)
// Dichiarazione e allocazione insieme
String[] materie = new String[4]; // 4 elementi null
// Inizializzazione con valori
int[] votiClasse = {7, 8, 6, 9, 8};
String[] materieBase = {"Italiano", "Matematica", "Storia", "Inglese"};
// Inizializzazione esplicita con new
int[] numeri = new int[]{1, 2, 3, 4, 5};Accesso agli Elementi
Leggere e Scrivere
int[] voti = {7, 8, 6, 9, 8};
// Accesso in lettura (indice da 0 a length-1)
int primoVoto = voti[0]; // 7
int ultimoVoto = voti[4]; // 8
int terzoVoto = voti[2]; // 6
// Accesso in scrittura
voti[2] = 7; // ora l'array e {7, 8, 7, 9, 8}
// Lunghezza dell'array
int numeroVoti = voti.length; // 5
// ATTENZIONE: indice fuori range causa ArrayIndexOutOfBoundsException
// voti[5] = 10; // ERRORE! Indice massimo e 4Iterazione sugli Array
Cicli su Array
String[] studenti = {"Mario", "Luigi", "Anna", "Sarà"};
int[] voti = {7, 8, 6, 9};
// for classico (utile quando serve l'indice)
System.out.println("=== Registro Voti ===");
for (int i = 0; i < studenti.length; i++) {
System.out.println(studenti[i] + ": " + voti[i]);
}
// for-each (più pulito quando non serve l'indice)
System.out.println("\n=== Lista Studenti ===");
for (String studente : studenti) {
System.out.println("- " + studente);
}
// Calcolo media con for-each
int somma = 0;
for (int voto : voti) {
somma += voto;
}
double media = (double) somma / voti.length;Operazioni Comuni
Utilita Array
import java.util.Arrays;
int[] voti = {7, 9, 6, 8, 7};
// Ordinamento
Arrays.sort(voti); // {6, 7, 7, 8, 9}
// Ricerca binaria (array deve essere ordinato!)
int indice = Arrays.binarySearch(voti, 8); // 3
// Confronto array
int[] altriVoti = {6, 7, 7, 8, 9};
boolean uguali = Arrays.equals(voti, altriVoti); // true
// Copia array
int[] copiaVoti = Arrays.copyOf(voti, voti.length);
int[] primiTre = Arrays.copyOfRange(voti, 0, 3); // {6, 7, 7}
// Riempimento
int[] nuoviVoti = new int[5];
Arrays.fill(nuoviVoti, 6); // {6, 6, 6, 6, 6}
// Stampa array
System.out.println(Arrays.toString(voti)); // [6, 7, 7, 8, 9]Array Multidimensionali
Matrici (Array 2D)
// Matrice voti: righe = studenti, colonne = materie
int[][] registroClasse = {
{7, 8, 6, 9}, // Mario: Ita, Mat, Sto, Ing
{8, 9, 7, 8}, // Luigi
{6, 7, 6, 7}, // Anna
{9, 8, 8, 9} // Sarà
};
String[] studenti = {"Mario", "Luigi", "Anna", "Sarà"};
String[] materie = {"Italiano", "Matematica", "Storia", "Inglese"};
// Accesso: registroClasse[riga][colonna]
int votoMarioMatematica = registroClasse[0][1]; // 8
int votoSaraInglese = registroClasse[3][3]; // 9
// Iterazione completa
System.out.println("╔══════════════════════════════════════════════╗");
System.out.println("║ REGISTRO DI CLASSE ║");
System.out.println("╠══════════════════════════════════════════════╣");
for (int i = 0; i < studenti.length; i++) {
System.out.printf("║ %-8s: ", studenti[i]);
double somma = 0;
for (int j = 0; j < materie.length; j++) {
System.out.printf("%d ", registroClasse[i][j]);
somma += registroClasse[i][j];
}
System.out.printf("| Media: %.1f ║%n", somma / materie.length);
}
System.out.println("╚══════════════════════════════════════════════╝");
Array Jagged (Frastagliati)
// Array con righe di lunghezza diversa
int[][] votiPerQuadrimestre = new int[2][];
votiPerQuadrimestre[0] = new int[]{7, 8, 6}; // Q1: 3 voti
votiPerQuadrimestre[1] = new int[]{8, 9, 7, 8}; // Q2: 4 voti
// Iterazione su array jagged
for (int q = 0; q < votiPerQuadrimestre.length; q++) {
System.out.print("Quadrimestre " + (q+1) + ": ");
for (int voto : votiPerQuadrimestre[q]) {
System.out.print(voto + " ");
}
System.out.println();
}Esempio Completo: Gestione Registro
GestioneRegistro.java
package it.scuola.registro;
import java.util.Arrays;
public class GestioneRegistro {
// Costanti
private static final int VOTO_MINIMO = 1;
private static final int VOTO_MASSIMO = 10;
private static final double SOGLIA_PROMOZIONE = 6.0;
public static void main(String[] args) {
// Dati del registro
String[] studenti = {"Mario Rossi", "Luigi Verdi", "Anna Bianchi", "Sarà Neri"};
String[] materie = {"Italiano", "Matematica", "Storia", "Inglese", "Scienze"};
int[][] voti = {
{7, 8, 6, 9, 7}, // Mario
{8, 9, 7, 8, 8}, // Luigi
{6, 5, 6, 7, 6}, // Anna
{9, 8, 8, 9, 9} // Sarà
};
// Stampa registro completo
stampaRegistro(studenti, materie, voti);
// Statistiche per studente
System.out.println("\n=== STATISTICHE STUDENTI ===");
for (int i = 0; i < studenti.length; i++) {
analizzaStudente(studenti[i], voti[i]);
}
// Statistiche per materia
System.out.println("\n=== STATISTICHE MATERIE ===");
for (int j = 0; j < materie.length; j++) {
int[] votiMateria = estraiColonna(voti, j);
System.out.printf("%s: Media %.2f%n", materie[j], calcolaMedia(votiMateria));
}
}
// Stampa il registro formattato
public static void stampaRegistro(String[] studenti, String[] materie, int[][] voti) {
System.out.println("╔════════════════════════════════════════════════════════════╗");
System.out.println("║ REGISTRO DI CLASSE ║");
System.out.println("╠════════════════════════════════════════════════════════════╣");
// Intestazione materie
System.out.print("║ Studente │");
for (String m : materie) {
System.out.printf(" %-4s│", m.substring(0, Math.min(4, m.length())));
}
System.out.println(" Media ║");
System.out.println("╠═════════════════╪══════════════════════════════════════════╣");
// Righe studenti
for (int i = 0; i < studenti.length; i++) {
System.out.printf("║ %-15s │", studenti[i]);
for (int voto : voti[i]) {
System.out.printf(" %2d │", voto);
}
System.out.printf(" %.2f ║%n", calcolaMedia(voti[i]));
}
System.out.println("╚════════════════════════════════════════════════════════════╝");
}
// Analizza un singolo studente
public static void analizzaStudente(String nome, int[] voti) {
double media = calcolaMedia(voti);
int max = trovaMax(voti);
int min = trovaMin(voti);
int insufficienze = contaInsufficienze(voti);
System.out.println("\n" + nome + ":");
System.out.printf(" Media: %.2f%n", media);
System.out.printf(" Voto max: %d, Voto min: %d%n", max, min);
System.out.printf(" Insufficienze: %d%n", insufficienze);
System.out.printf(" Esito: %s%n", determinaEsito(media, insufficienze));
}
// Calcola la media di un array di voti
public static double calcolaMedia(int[] voti) {
if (voti == null || voti.length == 0) return 0;
int somma = 0;
for (int v : voti) somma += v;
return (double) somma / voti.length;
}
// Trova il voto massimo
public static int trovaMax(int[] voti) {
int max = voti[0];
for (int v : voti) {
if (v > max) max = v;
}
return max;
}
// Trova il voto minimo
public static int trovaMin(int[] voti) {
int min = voti[0];
for (int v : voti) {
if (v < min) min = v;
}
return min;
}
// Conta le insufficienze
public static int contaInsufficienze(int[] voti) {
int count = 0;
for (int v : voti) {
if (v < 6) count++;
}
return count;
}
// Determina l'esito finale
public static String determinaEsito(double media, int insufficienze) {
if (media >= SOGLIA_PROMOZIONE && insufficienze == 0) {
return "PROMOSSO";
} else if (insufficienze <= 2) {
return "SOSPESO - Debiti formativi";
} else {
return "NON PROMOSSO";
}
}
// Estrae una colonna dalla matrice (voti di una materia)
public static int[] estraiColonna(int[][] matrice, int indiceColonna) {
int[] colonna = new int[matrice.length];
for (int i = 0; i < matrice.length; i++) {
colonna[i] = matrice[i][indiceColonna];
}
return colonna;
}
// Valida un voto
public static boolean votoValido(int voto) {
return voto >= VOTO_MINIMO && voto <= VOTO_MASSIMO;
}
}Conclusione
In questo articolo abbiamo esplorato i metodi in Java, dalla definizione all'overloading, e le strutture dati base come gli array mono e multidimensionali.
Nel prossimo articolo inizieremo la Programmazione a Oggetti (OOP): classi, oggetti, stato e comportamento.
Punti Chiave da Ricordare
- Metodi: Blocchi di codice riutilizzabili con nome, parametri e ritorno
- void: Metodi che non restituiscono nulla
- Overloading: Stesso nome, parametri diversi
- Passaggio per valore: I primitivi sono copiati, gli oggetti passano il riferimento
- Array: Strutture a dimensione fissa, indice da 0
- Arrays utility: sort(), binarySearch(), copyOf(), toString()