03 - Metodi e Strutture Dati Base

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.

Anatomia di un Metodo

// 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;
}

Metodi void vs con Ritorno

// 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

// 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);  // 47

Overloading dei Metodi

L'overloading permette di definire più metodi con lo stesso nome ma parametri diversi (numero, tipo o ordine).

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

Passaggio per Valore

In Java, tutti i parametri sono passati per valore. Questo significa che il metodo riceve una copia del valore.

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

// 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!
}

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

// 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

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 4

Iterazione sugli 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

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

// 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 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

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.