Creazione di oggetti con new

1. La parola chiave new

In Java, per creare un oggetto di qualsiasi classe si usa la parola chiave new. Questa «magica» parola chiede alla JVM: alloca la memoria per un nuovo oggetto e invoca per esso il costruttore.

Analogia:
Se una classe è il progetto di un’auto, allora new è la fabbrica che, seguendo quel progetto, assembla un’auto reale.

Esempio

Person vasya = new Person();

Cosa succede qui:

1. new Person() — viene creato un nuovo oggetto di tipo Person (viene chiamato il costruttore).
2. vasya — è una variabile che contiene il riferimento all’oggetto creato.

Come appare in memoria

Quando scrivi Person vasya = new Person();, in memoria viene allocata un’area per i campi dell’oggetto (per esempio, nome ed età), e la variabile vasya contiene l’indirizzo di quell’area — il riferimento.

Attenzione:
Se ti dimentichi di scrivere new, la variabile sarà solo un riferimento che non punta a nulla (null). Tentare di accedere ai campi o ai metodi di un oggetto «vuoto» del genere porterà a una NullPointerException.

2. Chiamata del costruttore: come funziona?

Un costruttore è un metodo speciale che viene chiamato alla creazione dell’oggetto e inizializza i suoi campi, preparando l’istanza all’uso.

Sintassi

ImyaKlassa imyaPeremennoy = new ImyaKlassa(argumenty);

• Se la classe ha un costruttore con parametri, è necessario passarli.
• Se il costruttore è senza parametri (o predefinito), le parentesi restano vuote.

Esempio: costruttore con parametri

public class Person {
    String name;
    int age;

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

Creiamo un oggetto:

Person petya = new Person("Petya", 25);

I valori "Petya" e 25 andranno nei campi name e age del nuovo oggetto.

Costruttore senza parametri

public Person() {
    this.name = "Senza nome";
    this.age = 0;
}

Ora si può scrivere:

Person mysteryMan = new Person(); // name="Senza nome", age=0

3. Lavorare con un oggetto: campi e metodi

Dopo aver creato un oggetto, puoi accedere ai suoi campi e metodi tramite l’operatore punto (.):

petya.name = "Pyotr";
System.out.println(petya.name); // Pyotr

petya.sayHello();

Se nella classe c’è un metodo:

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

Allora la chiamata petya.sayHello(); stamperà: Ciao, mi chiamo Pyotr!

Esempio: classe completa

public class Person {
    String name;
    int age;

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

    public void sayHello() { // metodo
        System.out.println("Ciao, mi chiamo " + name + "!");
    }
}

Uso:

Person vasya = new Person("Vasya", 30);
vasya.sayHello(); // Ciao, mi chiamo Vasya!

4. Variabili di riferimento: che cosa sono?

In Java, una variabile di tipo classe è un riferimento a un oggetto in memoria, non l’oggetto stesso.

Dimostrazione

Person vasya = new Person("Vasya", 30);
Person anotherVasya = vasya;

Ora sia vasya sia anotherVasya puntano allo stesso oggetto in memoria. Se si modifica un campo tramite una variabile, cambierà anche per l’altra:

anotherVasya.age = 31;
System.out.println(vasya.age); // 31

Aspetto importante:
Se si creano due oggetti diversi, essi sono indipendenti:

Person petya = new Person("Petya", 25);
Person masha = new Person("Masha", 22);

petya.age = 99;
System.out.println(masha.age); // 22 (non è cambiato!)

5. Esempio: creazione e uso di più oggetti

Aggiungiamo all’applicazione alcuni oggetti. Supponiamo di avere la classe Person, e in main creiamo alcune persone e stampiamo i loro saluti.

Classe Person

public class Person {
    String name;
    int age;

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

    public void sayHello() {
        System.out.println("Ciao, mi chiamo " + name + ", ho " + age + " anni!");
    }
}

Uso in main

public class Main {
    public static void main(String[] args) {
        Person vasya = new Person("Vasya", 25);
        Person petya = new Person("Petya", 27);

        vasya.sayHello(); // Ciao, mi chiamo Vasya, ho 25 anni!
        petya.sayHello(); // Ciao, mi chiamo Petya, ho 27 anni!

        // Dimostrazione dell'indipendenza degli oggetti:
        vasya.age = 100;
        vasya.sayHello(); // Ciao, mi chiamo Vasya, ho 100 anni!
        petya.sayHello(); // Ciao, mi chiamo Petya, ho 27 anni!
    }
}

Output del programma:

Ciao, mi chiamo Vasya, ho 25 anni!
Ciao, mi chiamo Petya, ho 27 anni!
Ciao, mi chiamo Vasya, ho 100 anni!
Ciao, mi chiamo Petya, ho 27 anni!

6. Errori tipici nella creazione degli oggetti

Errore n. 1: hai dimenticato di scrivere new

Person vasya;
vasya.name = "Vasya"; // NullPointerException!

La variabile vasya non fa riferimento ad alcun oggetto (null). Bisogna necessariamente creare un oggetto usando new.

Errore n. 2: non sono stati passati i parametri al costruttore

Person petya = new Person(); // Errore di compilazione, se non esiste un costruttore senza parametri

Se nella classe esiste solo un costruttore con parametri, è necessario specificare questi parametri durante la creazione dell’oggetto.

Errore n. 3: pensare che la variabile contenga l’oggetto stesso

Person a = new Person("Anya", 20);
Person b = a;
b.age = 99;
System.out.println(a.age); // 99, perché a e b sono riferimenti allo stesso oggetto!

In Java, una variabile di tipo classe è sempre un riferimento, non l’oggetto stesso.

Errore n. 4: si modificano i campi di un oggetto aspettandosi che l’altro non cambi

Person x = new Person("X", 1);
Person y = x;
x.age = 42;
System.out.println(y.age); // 42

Se servono due oggetti indipendenti — createli separatamente!