Scorri per mostrare il menu

Come semplificare l'inizializzazione di una classe

Inizializzare ogni campo ogni volta può essere laborioso. A tale scopo, le classi dispongono dei costruttori. La sintassi di un costruttore è la seguente:

Main.java


              1234
            
modifier ClassName(ParameterType parameter1, ParameterType parameter2) {
    this.parameter1 = parameter1;
    this.parameter2 = parameter2;
}

Analizziamo ogni termine qui riportato:

modifier: Si riferisce al modificatore di accesso, che spesso è public per i costruttori. I casi in cui un costruttore può avere un modificatore di accesso diverso saranno trattati in un corso separato;
ClassName: È semplicemente il nome della classe in cui si sta creando questo costruttore;
ParameterType: È il tipo di parametro che verrà utilizzato nel costruttore. È importante prestare attenzione perché questo parametro deve essere dello stesso tipo del campo nella classe; Ad esempio: Se la classe ha due parametri, String name e int age, allora il costruttore deve avere gli stessi parametri (se si desidera inizializzare tutti i campi tramite il costruttore). Se si desidera inizializzare solo un campo specifico della classe tramite il costruttore, ad esempio name, allora si deve utilizzare un solo parametro con lo stesso tipo e nome del campo nella classe;
Successivamente, all'interno del corpo del costruttore, si assegnano i valori ai campi della classe utilizzando i valori passati come parametro.

Parola chiave "this"

Con l'aiuto della parola chiave this, è possibile fare riferimento al campo della classe in cui si scrive il valore di questa parola chiave. Ad esempio, quando si dispone di una classe con due campi: name e age, è possibile scrivere this.name all'interno del costruttore o di un metodo, e farà riferimento specificamente al campo della classe, non alla variabile locale passata come parametro a quel costruttore o metodo. In questo modo, è possibile inizializzare i campi della classe tramite il costruttore utilizzando la sintassi: this.name = name;.

Esempio

Vediamo un esempio di costruttore in una classe che ci aiuterà a inizializzare tutti i campi per chiarire meglio il concetto:

Person.java


              1234567891011
            
class Person {
    String name;
    int age;
    String gender;

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

Abbiamo una classe chiamata Person con tre campi. Ognuno di questi campi è stato aggiunto al costruttore utilizzando la parola chiave this. Pertanto, il costruttore inizializza i campi con i valori dei parametri. Utilizziamo questo costruttore nel metodo main per mostrare che i campi vengono inizializzati con ciò che viene passato come parametro:

Main.java


              123456789101112131415161718192021
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

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

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
    }
}

Abbiamo inizializzato l'oggetto Person bob utilizzando il costruttore passando name, age e gender come parametri. Successivamente, abbiamo stampato i suoi parametri a schermo e verificato che l'oggetto possiede i valori dei campi come specificato nei parametri del costruttore.

Sovraccarico del Costruttore

Il costruttore può anche essere sovraccaricato e non coprire l'inizializzazione di tutti i campi della classe. Ad esempio, se non vogliamo specificare il genere di Alice, possiamo sovraccaricare il costruttore per accettare solo 2 parametri e inizializzare i campi con essi:

Main.java


              12345678910111213141516171819202122232425262728
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

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

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

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
    }
}

Si può concludere che un costruttore, come un metodo, può essere sovraccaricato e accettare diversi numeri e tipi di parametri.

Costruttore di Default

Un costruttore di default è un costruttore che non accetta parametri e non inizializza alcun campo. Esiste in tutte le classi per impostazione predefinita se non hanno altri tipi di costruttori, motivo per cui viene chiamato costruttore di default. Ogni volta che creiamo un oggetto di una qualsiasi classe, utilizziamo un costruttore. Per poter utilizzare il costruttore di default quando abbiamo già un costruttore che accetta parametri, è necessario scrivere anche un costruttore vuoto:

Main.java


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

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

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

    public Person() {
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
        Person john = new Person();
        System.out.println("John's name: " + john.name + ", John's age: " + john.age);
    }
}

Utilizziamo 3 costruttori diversi per inizializzare ciascun oggetto Person. Come si può vedere nell'ultimo esempio, John non ha né nome né età perché questi campi non sono stati inizializzati per l'oggetto. Pertanto, possiamo sovraccaricare il costruttore tutte le volte che è necessario e creare oggetti tramite esso.

1. Quale delle seguenti affermazioni sui costruttori è vera?

2. Qual è lo scopo di un costruttore in Java?

3. Quale dei seguenti frammenti di codice mostra il modo corretto per creare un costruttore parametrizzato?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 6

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Sezione 1. Capitolo 6