Che cos'è un costruttore in Java e come lo si usa?

Nella programmazione orientata agli oggetti, un costruttore è una funzione speciale che si chiama per creare un oggetto. I costruttori hanno diverse caratteristiche uniche che consentono loro di lavorare.

In Java, chiami un costruttore dopo la sua classe. Un costruttore è un metodo, definito nella classe a cui si applica. I costruttori Java possono utilizzare l'overload per fornire un comportamento alternativo. I costruttori in Java possono anche utilizzare l'ereditarietà per riutilizzare il codice.

Perché hai bisogno di costruttori comunque?

I costruttori sono un pilastro di programmazione orientata agli oggettie Java non fa eccezione. Questo esempio mostra come definire una classe Circle di base con una proprietà dei dati e un metodo:

cerchio di classe pubblica {
pubblico doppio raggio;
public double area() { return 3.14159 * raggio * raggio; }
}

Puoi quindi creare un'istanza di questa classe e interagire con essa:

Cerchio c = nuovo Cerchio();
c.raggio = 2;
System.out.println (c.area()); // 12.56636

Ma questo è meno conveniente e robusto di quanto potrebbe essere. È buona pratica orientata agli oggetti incapsulare i dati, proteggendoli da accessi non autorizzati:

cerchio di classe pubblica {
privato doppio raggio;
public double area() { return 3.14159 * raggio * raggio; }
public void setRadius (doppio r) { raggio = r; }
}

Ora il codice chiamante può utilizzare il setRadio metodo e non devi preoccuparti dei suoi dettagli di implementazione:

Cerchio c = nuovo Cerchio();
c.setRadius (2);

I costruttori offrono un modo ancora migliore di fornire dati a un oggetto quando lo crei. Sono molto spesso utilizzati per l'inizializzazione di proprietà, come il raggio Qui.

Esempi di semplici costruttori

Il costruttore più elementare è uno senza argomenti, che non fa nulla:

cerchio di classe pubblica {
cerchio pubblico() {}
}

Guarda anche: Impara come creare classi in Java

Se non definisci un costruttore, Java ne fornirà uno predefinito che si comporterà allo stesso modo.

Nota un paio di cose:

1. Il nome del costruttore corrisponde al nome della classe.
2. Questo costruttore usa il pubblico modificatore di accesso, quindi qualsiasi altro codice può chiamarlo.
3. Un costruttore non include un tipo restituito. A differenza di altri metodi, i costruttori non possono restituire un valore.

I costruttori in genere eseguono una sorta di inizializzazione. Nota che il codice sopra non inizializza il valore di raggio. In questo caso, la lingua lo imposterà automaticamente a zero. Questa classe si aspetta che un utente utilizzi setRadio(). Per utilizzare un valore predefinito più utile di 0, puoi assegnarlo all'interno del costruttore:

cerchio di classe pubblica {
Cerchio pubblico() { raggio = 1; }
}

I cerchi creati con questa classe almeno ora avranno un'area reale! Il chiamante può ancora usare setRadio() per fornire un raggio diverso da 1. Ma il costruttore può essere ancora più amichevole:

cerchio di classe pubblica {
Circolo pubblico (doppio r) { raggio = r; }
}

Ora puoi creare cerchi con un raggio specifico fin dalla nascita:

Cerchio c = nuovo Cerchio (2);
System.out.println (c.area()); // 12.56636

Questo è un uso molto comune per i costruttori. Li utilizzerai spesso per inizializzare le variabili sui valori dei parametri.

Sovraccarico del costruttore

È possibile specificare più di un costruttore in una definizione di classe:

Cerchio pubblico() { raggio = 1; }
Circolo pubblico (doppio r) { raggio = r; }

Questo dà al codice chiamante una scelta su come costruire oggetti:

Cerchio c1 = nuovo Cerchio (2);
Cerchio c2 = nuovo Cerchio();
System.out.println (c1.area() + ", " + c2.area()); // 12.56636, 3.14159

Con un cerchio leggermente più complesso, puoi esplorare costruttori più interessanti. Questa versione memorizza la sua posizione:

cerchio di classe pubblica {
doppio pubblico x, y, raggio;
Cerchio pubblico() { raggio = r; }
Circolo pubblico (doppio r) { raggio = r; }
Public Circle (doppia x, doppia y, doppia r) {
questo.x = x; questo.y = y; raggio = r;
}
public double area() { return 3.14159 * raggio * raggio; }
}

Ora puoi creare un cerchio senza argomenti, un raggio singolo o le coordinate x e y accanto al raggio. Questo è lo stesso tipo di sovraccarico supportato da Java per qualsiasi metodo.

Concatenamento costruttore Con

Che ne dici di creare un Cerchio, basato su un altro? Questo ci darebbe la possibilità di copiare facilmente i cerchi. Osserva il seguente blocco:

Cerchio pubblico (Cerchio c) {
questo.x = c.x;
questo.y = c.y;
questo.raggio = c.raggio;
}

Funzionerà, ma ripete del codice inutilmente. Poiché la classe Circle ha già un costruttore che gestisce le singole proprietà, puoi chiamarlo invece usando il Questo parola chiave:

Cerchio pubblico (Cerchio c) {
questo (c.x, c.y, c.radius);
}

Questa è una forma di concatenamento di costruttori, che chiama un costruttore da un altro. Utilizza meno codice e aiuta a centralizzare un'operazione anziché duplicarla.

Chiamare il Costruttore Genitore

L'altra forma di concatenamento del costruttore si verifica quando un costruttore chiama un costruttore della sua classe genitore. Questo può essere esplicito o implicito. Per chiamare esplicitamente un costruttore genitore, usa il super parola chiave:

super (x, y);

Immagina una classe Shape che agisce come genitore del Circle:

classe pubblica Forma {
doppia x, y;
forma pubblica (doppio _x, doppio _y) { x = _x; y = _y; }
}

Gestisce il posizionamento comune per tutte le forme poiché questa è la funzionalità che tutti condividono. Ora la classe Circle può delegare la gestione della posizione al suo genitore:

Circolo di classe pubblica estende la forma {
doppio raggio;
Public Circle (doppia r) { super (0, 0); raggio = r; }
Public Circle (doppia x, doppia y, doppia r) {
super (x, y);
raggio = r;
}
}

La costruzione della superclasse è un aspetto molto importante di ereditarietà in Java. La lingua lo applica per impostazione predefinita se non chiami esplicitamente super nei tuoi costruttori

Modificatori di accesso sui costruttori

I costruttori possono includere un modificatore di accesso nella loro firma. Come altri metodi, questo definisce quali tipi di chiamante possono accedere al costruttore:

prova di classe pubblica {
private static Test uniqueInstance = new Test();
prova privata() { }
test statico pubblico getInstance() {
restituisce istanza unica;
}
}

Questo è un esempio più complicato, quindi fai attenzione a capirlo:

• La classe non è astratta, quindi è possibile creare un'istanza da essa.
• Il costruttore è privato, quindi solo questa classe stessa può creare una nuova istanza.
• Tramite una proprietà e un metodo statici, la classe espone una singola istanza univoca ai chiamanti.

Usa i costruttori in Java per creare oggetti

I costruttori sono vitali per la programmazione orientata agli oggetti. Ti permettono di creare oggetti, il che è essenziale!

In Java, i costruttori assomigliano ad altri metodi e funzionano più o meno allo stesso modo. Dovresti ricordare le regole speciali sui costruttori predefiniti, l'overload e il concatenamento dei costruttori. Se i costruttori sono nuovi per te, potresti voler leggere gli altri concetti fondamentali di Java che dovresti imparare quando inizi.

10 concetti fondamentali di Java che dovresti imparare quando inizi

Sia che tu stia scrivendo una GUI, sviluppando software lato server o un'applicazione mobile utilizzando Android, l'apprendimento di Java ti sarà utile. Ecco alcuni concetti fondamentali di Java per aiutarti a iniziare.

Leggi Avanti

Circa l'autore