Classi in Java: definire campi, metodi e oggetti

Una classe è un progetto

Finora il tuo codice è vissuto in metodi che si passano valori semplici. Una classe ti permette di raggruppare dati correlati e il comportamento che opera su di essi in un unico tipo con un nome. La classe è il progetto; le cose concrete con cui lavori sono gli oggetti creati a partire da essa.

Una classe dichiara due tipi di membri: i campi (i dati che ogni oggetto contiene) e i metodi (ciò che ogni oggetto sa fare).

class Dog {
    String name;          // un campo: ogni Dog ha un nome
    int age;              // un altro campo

    void bark() {         // un metodo: comportamento che ogni Dog possiede
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // crea un oggetto a partire dal progetto
        d.name = "Rex";       // imposta i suoi campi
        d.age = 3;
        d.bark();             // chiama il suo metodo
    }
}

new Dog() costruisce un oggetto in memoria e ti restituisce un riferimento a esso. d.name e d.bark() agiscono proprio su quell'oggetto.

Ogni oggetto ha il proprio stato

Il senso di una classe è che puoi produrre molti oggetti indipendenti, ognuno con i propri valori dei campi. Cambiarne uno non tocca mai gli altri.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex e bella sono due oggetti distinti. Ognuno ha il proprio name, quindi ogni bark() stampa un valore diverso. Questi dati propri di ciascun oggetto si chiamano stato di istanza.

Campi e metodi lavorano insieme

I metodi di una classe possono leggere e aggiornare direttamente i campi del proprio oggetto, senza bisogno di riceverli come parametri. Il metodo "vive" già sull'oggetto di cui tocca i dati.

class Counter {
    int count;            // parte da 0 di default

    void increment() {
        count++;          // aggiorna il campo di questo oggetto
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Nota che increment() non riceve argomenti. Lavora sul campo del Counter su cui lo hai chiamato. È questa la differenza tra un metodo di classe e un metodo static isolato: il metodo ha un oggetto implicito su cui agire.

La parola chiave this

Dentro un metodo, this è un riferimento all'oggetto su cui il metodo è stato chiamato. Di solito non ti serve: scrivere count significa già this.count. Ma this diventa indispensabile quando il nome di un parametro coincide con quello di un campo, cosa che succede di continuo nei setter e nei costruttori.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x è il campo; x è il parametro
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

Un errore tipico dei principianti è scrivere x = x; dentro move. Così assegni il parametro a se stesso e il campo resta invariato: il compilatore non ti avvisa e l'oggetto mantiene in silenzio i vecchi valori. È this.x = x; che aggiorna davvero il campo.

Valori predefiniti dei campi e riferimenti null

Quando crei un oggetto, i suoi campi non contengono dati casuali: Java li inizializza con valori predefiniti, cioè 0 per i numeri, false per boolean e null per i riferimenti a oggetti come String. Quel null predefinito è l'origine di un crash classico.

class User {
    String name;          // non assegnato, quindi vale null di default
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name è null perché nessuno lo ha impostato, quindi chiamare .length() su di esso lancia una NullPointerException. Assegna sempre valori sensati a un oggetto prima di usarne i campi: è proprio il problema che risolvono i costruttori.

Organizzare il codice attorno alle classi

I programmi reali modellano il proprio dominio con classi che tengono insieme i dati e le operazioni su di essi. Qui una sola classe BankAccount conserva un saldo e controlla come cambia:

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // fondi insufficienti
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

I dati (balance) e le regole per modificarli (deposit, withdraw) stanno in un unico punto. Il codice altrove chiede al conto di fare qualcosa invece di mettere mano direttamente ai suoi numeri: è la base di un design pulito e facile da mantenere.

Prossimo passo: i costruttori

Impostare a mano ogni campo dopo new è noioso e facile da dimenticare, e come hai appena visto un campo dimenticato lascia un null pronto a far crashare il programma. Un costruttore ti permette di richiedere e inizializzare i campi di un oggetto nel momento stesso in cui viene creato, così un BankAccount non può mai esistere senza un titolare. È l'argomento della prossima pagina.