I metodi in Java definiscono ciò che un oggetto sa fare. Possono leggere lo stato dell’oggetto, modificarlo, ricevere parametri e restituire risultati. Questa lezione, basata sugli appunti del corso, usa programmi completi e tabelle di traccia.

Attributi, metodi e parametri: cosa cambia?

Un attributo d’istanza appartiene allo stato di un oggetto. Un parametro esiste durante l’esecuzione del metodo e riceve un valore dall’esterno. Una variabile locale è dichiarata nel corpo del metodo e non costituisce lo stato permanente dell’oggetto.

Un esempio completo con la classe Contatore

class Contatore {
    private int valore;

    public void incrementa() {
        valore++;
    }

    public void aggiungi(int quantita) {
        if (quantita > 0) {
            valore += quantita;
        }
    }

    public int getValore() {
        return valore;
    }
}

public class Main {
    public static void main(String[] args) {
        Contatore primo = new Contatore();
        Contatore secondo = new Contatore();

        primo.incrementa();
        primo.aggiungi(4);
        secondo.incrementa();

        System.out.println(primo.getValore());  // 5
        System.out.println(secondo.getValore()); // 1
    }
}

Il codice del metodo incrementa() esiste una volta nella classe; quando lo richiamiamo tramite primo lavora sullo stato di primo, e tramite secondo lavora sullo stato di secondo. Ogni istanza conserva il proprio valore.

Come leggere la firma di un metodo

public int getValore() {
    return valore;
}

public void aggiungi(int quantita) {
    if (quantita > 0) {
        valore += quantita;
    }
}

• public è il modificatore di accesso: il metodo è invocabile dal codice esterno se la classe è accessibile.
• int è il tipo del valore restituito; return riconsegna il risultato al chiamante.
• void indica che il metodo non restituisce un valore.
• quantita è un parametro di tipo int; a ogni chiamata riceve il valore dell’argomento.

Traccia: lo stato dopo ogni chiamata

Metodi che osservano lo stato e metodi che lo modificano

Il metodo getValore() osserva lo stato e restituisce un numero; incrementa() e aggiungi() lo modificano. Separare chiaramente le operazioni aiuta a progettare classi comprensibili.

Esempio: un metodo con risultato calcolato

class Rettangolo {
    private double base;
    private double altezza;

    public Rettangolo(double base, double altezza) {
        this.base = base;
        this.altezza = altezza;
    }

    public double area() {
        return base * altezza;
    }
}

public class Main {
    public static void main(String[] args) {
        Rettangolo r = new Rettangolo(5, 3);
        System.out.println(r.area()); // 15.0
    }
}

Il metodo area() restituisce un valore derivato dai campi senza dover memorizzare un attributo aggiuntivo area. In un progetto completo il costruttore dovrebbe anche validare dimensioni positive: l’esempio qui si concentra sulla differenza fra stato e calcolo.

Errori comuni sui metodi Java

• Dimenticare return in un metodo che promette di restituire un valore.
• Credere che un parametro locale continui a esistere dopo la chiamata.
• Confondere void con un metodo che restituisce zero.
• Scrivere tutta la logica nel main() anziché attribuire responsabilità agli oggetti.
• Credere che un metodo chiamato su un oggetto modifichi automaticamente tutte le istanze della classe.

Esercizi svolgibili

• Aggiungi al Contatore il metodo azzera() e costruisci una tabella di traccia.
• Scrivi una classe Termometro con un campo temperatura, un metodo di aggiornamento e un metodo isSottoZero().
• Scrivi il metodo perimetro() per Rettangolo e prova i valori 4 e 7.
• Spiega cosa succede se crei due Contatore e incrementi solo il primo.

Controllo: per un rettangolo di lati 4 e 7 il perimetro deve essere 22; per un contatore iniziale zero, dopo due incrementi e una chiamata ad azzera() il valore torna a zero.

Nel percorso OOP: Torna all’indice delle lezioni Java · Ripassa classi e oggetti.