Struttura di una classe: campi, metodi, costruttori

1. Campi della classe: dove conserviamo lo stato dell’oggetto

Campo — è una variabile dichiarata all’interno della classe, ma al di fuori di tutti i metodi. I campi servono a far sì che ogni oggetto abbia il proprio «stato». Per esempio, se abbiamo la classe Person, i campi possono essere:

• name — nome della persona
• age — età
• balance — saldo sul conto (se stiamo realizzando un’app bancaria)
• isStudent — flag che indica se la nostra persona è uno studente

Sintassi di dichiarazione di un campo

La dichiarazione di un campo è simile a una variabile normale, solo che non si trova dentro un metodo, ma direttamente nella classe:

public class Person {
    String name;
    int age;
}

Qui abbiamo dichiarato due campi: una stringa name e un intero age. Ogni campo apparterrà a un oggetto specifico di questa classe. Ciò significa che oggetti diversi avranno i propri valori. Per esempio:

Person p1 = new Person();
p1.name = "Olya";
p1.age = 20;

Person p2 = new Person();
p2.name = "Igor’";
p2.age = 25;

Il primo oggetto ha il nome «Olya» e l’età 20, mentre il secondo — «Igor’» e 25. Sono entrambi creati dalla stessa classe, ma i loro campi conservano dati diversi.

Modificatori di accesso (public/private)

I campi possono essere pubblici (public) o privati (private). Nella vita reale non racconti a chiunque il saldo del tuo conto, giusto? Allo stesso modo, in programmazione spesso si rendono i campi private, così non è possibile accedervi direttamente da altre classi. Questo fa parte del principio di incapsulamento (ne parleremo in dettaglio nelle prossime lezioni).

Esempio:

public class Person {
    private String name;
    private int age;
}

Per il momento non complichiamo le cose, ma ricordate: se un campo è private, non è possibile accedervi direttamente da un’altra classe.

2. Metodi della classe: come gli oggetti «agiscono»

Metodo — è una funzione che descrive il comportamento dell’oggetto. I metodi permettono all’oggetto di fare qualcosa: parlare, calcolare, correre, saltare, stampare informazioni su di sé e così via.

Sintassi di dichiarazione di un metodo

tipo_di_ritorno nomeMetodo(parametri) {
    // corpo del metodo
}

Esempio di metodo che dice «Ciao»:

public void sayHello() {
    System.out.println("Ciao! Mi chiamo " + name);
}

Qui:

• public — modificatore di accesso.
• void — il metodo non restituisce nulla (fa solo qualcosa).
• sayHello — nome del metodo.
• All’interno del metodo usiamo il campo name per salutare l’utente.

Altro esempio: metodo che restituisce l’età

public int getAge() {
    return age;
}

I metodi possono restituire valori (int, String, ecc.) oppure non restituire nulla — in tal caso si usa void.

3. Costruttori: come «nascono» gli oggetti

Costruttore — è un metodo speciale che viene invocato alla creazione di un nuovo oggetto. Il suo compito è inizializzare i campi dell’oggetto con valori iniziali, cioè riempire le «tasche vuote» dell’oggetto con dati concreti. Per esempio, impostare subito nome ed età di una persona al momento della creazione, invece di lasciarli vuoti.

• Il nome del costruttore coincide sempre con quello della classe.
• Un costruttore non ha tipo di ritorno (non si scrive nemmeno void).
• I costruttori possono accettare parametri (per esempio, nome ed età) oppure non averne.

Esempio di costruttore

public class Person {
    String name;
    int age;

    // Costruttore con due parametri
    public Person(String name, int age) {
        this.name = name; // this.name — campo dell’oggetto, name — parametro del costruttore
        this.age = age;
    }
}

Probabilmente ti starai chiedendo cos’è questo this. Ebbene, la parola chiave this è un riferimento all’oggetto corrente, dall’interno. La usiamo per distinguere il campo della classe dal parametro con lo stesso nome. Senza this il compilatore si confonderebbe su quale valore vogliamo inizializzare.

Costruttore predefinito

Se non dichiari alcun costruttore, il compilatore Java aggiunge automaticamente un costruttore vuoto senza parametri. Ha questo aspetto:

public Person() {
    // non fa nulla, ma consente di creare un oggetto senza parametri
}

MA! Se dichiari almeno un tuo costruttore (per esempio con parametri), il costruttore predefinito non viene più creato automaticamente! Se ti serve — scrivilo esplicitamente.

4. Esempio di classe completa

Mettiamo tutto insieme: campi, metodi, costruttore.

public class Person {
    String name;
    int age;

    // Costruttore
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Metodo: dire ciao
    public void sayHello() {
        System.out.println("Ciao! Mi chiamo " + name + ", ho " + age + " anni.");
    }

    // Metodo: aumentare l’età di 1
    public void haveBirthday() {
        age = age + 1;
        System.out.println("Evviva! Ora ho " + age + " anni!");
    }
}

Come usarlo in un programma?

public class Main {
    public static void main(String[] args) {
        Person vasya = new Person("Vasya", 18);
        vasya.sayHello();      // Ciao! Mi chiamo Vasya, ho 18 anni.
        vasya.haveBirthday();  // Evviva! Ora ho 19 anni!
    }
}

5. Pratica: sviluppiamo la tua applicazione

Supponiamo che tu stia creando una semplice applicazione per la gestione degli utenti. Nelle lezioni precedenti abbiamo lavorato solo con variabili e metodi dentro main. Ora creiamo una classe User con campi, metodi e costruttore.

public class User {
    String username;
    int score;

    // Costruttore
    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    // Metodo: stampare le informazioni sull’utente
    public void printInfo() {
        System.out.println("Nome utente: " + username + ", punti: " + score);
    }

    // Metodo: aumentare il punteggio
    public void addScore(int points) {
        score += points;
        System.out.println(username + " ha ottenuto " + points + " punti! Ora ha " + score + " punti.");
    }
}

Uso:

public class Main {
    public static void main(String[] args) {
        User alice = new User("Alice", 10);
        User bob = new User("Bob", 5);

        alice.printInfo(); // Nome utente: Alice, punti: 10
        bob.printInfo();   // Nome utente: Bob, punti: 5

        alice.addScore(7); // Alice ha ottenuto 7 punti! Ora ha 17 punti.
        bob.addScore(3);   // Bob ha ottenuto 3 punti! Ora ha 8 punti.
    }
}

Nota: ogni oggetto ha i propri campi e le modifiche a un oggetto non influenzano l’altro.

6. In breve sui modificatori di accesso

Nei nostri esempi i campi erano pubblici (String name;). Nella pratica spesso si rendono i campi private, per evitare che possano essere modificati per errore (o apposta) da un’altra classe. Approfondiremo nella lezione sull’incapsulamento, ma ecco un esempio:

public class User {
    private String username;
    private int score;

    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    public void printInfo() {
        System.out.println("Nome utente: " + username + ", punti: " + score);
    }

    public void addScore(int points) {
        score += points;
    }
}

Ora, se qualcuno prova a scrivere alice.score = 100500 al di fuori della classe — il compilatore dirà «vietato!».

7. Errori tipici nell’uso di campi, metodi e costruttori

Errore n. 1: Campi non inizializzati.
Se non assegni valori ai campi, ricevono i valori predefiniti: i numeri — 0, boolean — false, i riferimenti (per esempio, String) — null. Se ti dimentichi di inizializzare un campo, puoi ottenere un risultato inatteso o persino una NullPointerException quando provi a usarlo.

Errore n. 2: Confusione tra parametri e campi.
Nel costruttore i principianti spesso scrivono semplicemente name = name; — questo non inizializza il campo, ma assegna il parametro a sé stesso. Usa sempre this.name = name!

Errore n. 3: Mancanza del costruttore predefinito.
Se dichiari un costruttore con parametri ma dimentichi di aggiungere esplicitamente quello vuoto, new Person() non funzionerà più.

Errore n. 4: Nomi identici per metodi e classi.
In Java il nome del costruttore deve coincidere con quello della classe, mentre per i metodi non deve. A volte per errore si dà a un metodo lo stesso nome della classe, e il compilatore si lamenta.

Errore n. 5: Dimenticare i modificatori di accesso.
Se rendi i campi public, possono essere modificati ovunque — per i programmi grandi è rischioso. È meglio abituarsi fin da subito a private e usare metodi per l’accesso.