Costruttore Java

java constructor class

Prova Il Nostro Strumento Per Eliminare I Problemi

Seleziona Il Sistema Operativo Scegli Un Programma Di Proiezione (Facoltativamente)

Descrivi Il Tuo Problema

Questo tutorial discuterà Java Constructor, i suoi tipi e concetti come il sovraccarico del costruttore e il concatenamento dei costruttori con esempi di codice:

Dai nostri tutorial precedenti, sappiamo che l'istanza di una classe è chiamata oggetto. Un oggetto di una classe viene creato utilizzando la parola chiave 'new'. Un metodo speciale chiamato 'costruttore' viene chiamato quando creiamo un oggetto con una nuova parola chiave o quando l'oggetto viene istanziato.

Un costruttore è definito come un blocco di codice per inizializzare l'oggetto classe. È identico al metodo ma non è un metodo. Tuttavia, può essere definito come un 'metodo speciale' in Java.

=> Controlla qui per vedere qui i tutorial di formazione su Java dalla A alla Z.

Costruttori in Java

Cosa imparerai:

Costruttore Java
Conclusione
- Lettura consigliata

Il costruttore Java viene utilizzato per inizializzare l'oggetto appena creato. Un oggetto necessita di alcuni dati prima di essere utilizzato nel programma. Quindi usiamo il costruttore in modo da poter assegnare alcuni dati iniziali all'oggetto.

Come semplice esempio, si consideri una classe ABC per la quale è necessario creare un oggetto. Creiamo un oggetto 'myObj' per la classe ABC utilizzando una nuova parola chiave.

ABC myObj = new ABC ();

L'istruzione precedente crea un oggetto myObj. Quando questo oggetto viene creato, viene chiamato un costruttore per la classe ABC senza argomenti (ABC () descrive che non ci sono argomenti per il costruttore). Poiché non ci sono argomenti forniti per il costruttore precedente, i campi membro di myObj verranno inizializzati ai loro valori iniziali predefiniti.

Per esempio,

I tipi di dati numerici come int sono impostati su 0.
Il valore della variabile del tipo di dati Char è impostato su carattere nullo (' 0').
I riferimenti sono impostati su null.

In questo tutorial, discuteremo i costruttori in dettaglio insieme ai vari costruttori usati in Java.

Come creare un costruttore in Java

Per creare un costruttore in Java, dobbiamo seguire alcune regole come indicato di seguito.

Il costruttore della classe ha lo stesso nome di quello della classe.
Non può esserci un costruttore finale, astratto, sincronizzato o statico. Questo perché la Finale agisce come una costante, l'astratto non può essere istanziato. Mentre sincronizzato viene utilizzato nel caso del multi threading, e la parola chiave statica viene utilizzata a livello di classe.
Possiamo usare modificatori di accesso con i costruttori.
Un costruttore non può avere un tipo restituito.

Per esempio,definiamo una classe Studente come segue:

class Student{ String name; int roll_no; }

Possiamo creare oggetti della classe precedente usando la nuova parola chiave. Durante la creazione dell'oggetto, possiamo inizializzare le variabili a due membri di questa classe fornendo un costruttore. Nota che anche se non forniamo un costruttore ed eseguiamo semplicemente l'istruzione seguente,

Studente studente = nuovo Studente ();

Tuttavia, Java eseguirà un costruttore predefinito che inizializzerà le variabili a due membri sui valori predefiniti del sistema. Ora, se vogliamo che il valore iniziale di Student.name sia 'Keith' e roll_no sia 27, per fare ciò possiamo creare il seguente metodo di costruzione.

Student () { name = 'Keith'; roll_no = 27; }

Quando creiamo un oggetto della classe studente con la dichiarazione seguente

Student student = new Student ();

Quindi i valori iniziali delle variabili membro name e roll_no saranno rispettivamente Keith e 27.

Ora che è stato creato un costruttore, quando verrà chiamato?

Un costruttore viene chiamato ogni volta che viene creato un oggetto con la nuova parola chiave come nel caso precedente. Come già accennato, se non viene fornito alcun costruttore, Java fornisce un costruttore predefinito che viene chiamato quando l'oggetto viene creato utilizzando la nuova parola chiave.

Esempio di costruttore

Il seguente programma mostra un esempio di costruttore in cui abbiamo un semplice costruttore senza argomenti. Questo costruttore assegna semplicemente i valori iniziali alle sue variabili membro.

//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }

Produzione:

Esempio di output di dimostrazione di classe

Costruttore predefinito in Java

Il costruttore predefinito è anche chiamato Empty Constructor . Questo costruttore viene inserito dal compilatore Java nel codice della classe dove non esiste un costruttore implementato dal programmatore. Il costruttore predefinito viene inserito durante la compilazione e quindi apparirà solo nel file '.class' e non nel codice sorgente.

Considera la seguente classe Java.

file sorgente (.java) file di classe (.class)

Classe Java

Nella figura sopra, la prima figura mostra il codice sorgente in cui non abbiamo specificato alcun costruttore. Quindi quando compiliamo questo codice e viene generato il file .class, possiamo vedere che il compilatore Java ha inserito un costruttore predefinito come mostrato nella figura adiacente (in colore blu).

Nota:

A volte un costruttore predefinito viene utilizzato per descrivere il costruttore senza argomenti in Java. Ma questi due termini sono diversi nella realtà. Il costruttore senza argomenti è un tipo di costruttore in Java specificato dal programmatore. Il costruttore predefinito è il costruttore inserito dal compilatore Java.

algoritmo di ordinamento heap c ++

Pertanto, sebbene questi due termini siano usati in modo intercambiabile dalla maggior parte del programmatore, è consigliabile non confondere questi due termini.

Quando Java inserisce un costruttore predefinito, se il programma ha delle variabili, vengono assegnati i valori predefiniti.

La tabella seguente mostra i valori predefiniti di ogni tipo di dati.

genere	Valore di default
char	u0000
Oggetto	Riferimento nullo
booleano	falso
byte	0
corto	0
int	0
lungo	0L
galleggiante	0.0f
Doppio	0.0d

Il seguente programma fornisce un esempio di un costruttore predefinito in Java.

class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }

Produzione:

costruttore predefinito - output

Tipi di costruttori in Java

Esistono due tipi di costruttori in Java, come mostrato di seguito.

Tipi di costruttori in Java

# 1) Costruttore senza argomenti

Un costruttore senza argomenti è chiamato costruttore no-args o no-argument. Se non abbiamo un costruttore senza argomenti, il compilatore Java non crea un costruttore predefinito per la classe.

In generale, se definiamo un costruttore nella nostra classe, il costruttore predefinito non viene inserito dal compilatore Java.

Di seguito è riportato un esempio del Costruttore No-arg

import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } }

Produzione:

Costruttore senza argomenti

In questo programma, abbiamo fornito un costruttore senza argomenti. Qui stampiamo alcuni messaggi che includono le variabili membro. Possiamo vedere nell'output che i messaggi dal costruttore vengono visualizzati indicando che il costruttore no-args viene eseguito.

# 2) Costruttore parametrizzato

Un costruttore parametrizzato ha uno o più parametri. Possiamo usare un costruttore parametrizzato nel caso in cui abbiamo bisogno di passare alcuni valori iniziali alla variabile membro della classe.

import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } }

Produzione:

Costruttore parametrizzato in Java

Qui abbiamo fornito un costruttore parametrizzato che accetta due argomenti, ovvero nome e id.

All'interno del corpo del costruttore, gli argomenti vengono assegnati come valori rispettivamente al nome e all'id delle variabili membro.

Quindi, nel metodo principale, quando creiamo un nuovo oggetto utilizzando la nuova parola chiave, passiamo due valori al nome della classe dopo una nuova parola chiave. Ciò indica che stiamo chiamando il costruttore parametrizzato. Quando visualizziamo le variabili membro, possiamo vedere che hanno i valori che abbiamo passato durante la creazione dell'oggetto.

Costruttori sovraccaricati in Java

Ora sorge la domanda se una classe può avere più di un costruttore o è che una classe può avere un solo costruttore?

Bene, possiamo avere più costruttori in una classe. Una classe può contenere tanti costruttori purché siano adeguatamente sovraccaricati.

Allora cosa si intende esattamente per sovraccarico di costruttori?

Constructor Overloading è un meccanismo che consente a una classe di avere tanti costruttori in modo che tutti questi costruttori abbiano elenchi di parametri diversi a seconda dei tipi di parametro o dell'ordine dei parametri.

Il programma seguente mostra il sovraccarico del costruttore.

//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }

Produzione:

Sovraccarico - uscita

Nel programma precedente, abbiamo una classe contenente tre costruttori. Il primo costruttore è un costruttore senza argomenti, quindi ne abbiamo uno ciascuno con un argomento e due argomenti rispettivamente. Poiché il costruttore ha un elenco di parametri univoco, possiamo dire che i costruttori sono sovraccarichi.

Costruttore 'this ()' in Java

In una classe contenente più costruttori, cosa succede se si desidera chiamare un costruttore da un altro costruttore in questa classe?

A questo scopo, utilizziamo la parola chiave “this” all'interno del costruttore dal quale vogliamo chiamare un altro costruttore.

Quindi, quando una classe ha più costruttori, un costruttore senza argomenti e un costruttore parametrizzato, utilizziamo la parola chiave 'this' per chiamare un costruttore parametrizzato dal costruttore senza argomenti. Questo è anche chiamato 'Invocazione esplicita del costruttore'.

Perché abbiamo bisogno di questa parola chiave?

Ne abbiamo bisogno perché l'invocazione esplicita dei costruttori non è possibile direttamente utilizzando solo il nome del costruttore.

Punti da notare:

La parola chiave 'this' dovrebbe essere la prima istruzione nel costruttore chiamante.
Se un costruttore ha la parola chiave 'this', non può avere 'super'. Ciò significa che il costruttore può avere super o this.

class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }

Produzione:

Costruttore

Nel programma sopra, abbiamo una 'TestClass' con due costruttori. Lo chiamiamo ('SoftwareTestingHelp') dal costruttore no-args. Questa è la chiamata esplicita del costruttore parametrizzato.

Copia costruttore in Java

Siamo a conoscenza del costruttore di copie in C ++. Il costruttore di copia è un costruttore che ha un riferimento a un oggetto come argomento e un nuovo oggetto viene creato utilizzando i dati dell'oggetto di riferimento.

C ++ fornisce un costruttore di copia predefinito se non è fornito nel programma.

Java fornisce anche il supporto per il costruttore di copie, ma non fornisce un costruttore di copie predefinito.

Il seguente programma Java mostra il costruttore di copie utilizzando il classico esempio di numeri complessi che hanno componenti reali e immaginari.

class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } }

Produzione:

Copia costruttore in Java 7

Il programma precedente ha una classe 'Complex' che ha un costruttore parametrizzato e un costruttore di copia. Nel metodo principale creiamo prima un oggetto c1 utilizzando un costruttore parametrizzato. Quindi utilizzando la dichiarazione seguente,

Complex c2 = new Complex (c1);

L'istruzione precedente chiama il costruttore di copia quando il riferimento c1 viene passato al costruttore durante la creazione di un nuovo oggetto c2.

Costruttore concatenato in Java

Il concatenamento del costruttore è un processo di un costruttore che chiama un altro costruttore della stessa classe.

Anche quando abbiamo ereditato da una classe base, il costruttore della classe base viene richiamato per primo quando viene creato l'oggetto classe figlio. Questo è anche un esempio di concatenamento dei costruttori.

In Java, il concatenamento del costruttore può essere ottenuto utilizzando due approcci:

All'interno della stessa classe : Quando chiamiamo un costruttore da un altro costruttore della stessa classe, possiamo usare la parola chiave this ().
Dalla classe base: Un costruttore della classe base può essere chiamato da quello della classe derivata utilizzando la parola chiave super.

Perché abbiamo bisogno del concatenamento dei costruttori?

Quando vogliamo eseguire più attività nel nostro costruttore, invece di eseguire ogni attività in un costruttore, suddividiamo le attività in più costruttori, quindi chiamiamo i costruttori l'uno dall'altro con conseguente concatenamento dei costruttori.

Di seguito sono riportate alcune delle regole che dobbiamo seguire durante l'esecuzione del concatenamento dei costruttori.

Il concatenamento del costruttore viene eseguito in qualsiasi ordine e produrrà gli stessi risultati.
L'espressione 'questa' parola chiave dovrebbe essere la prima espressione nel costruttore.
Dovremmo avere almeno un costruttore senza questa parola chiave.

Quando abbiamo un'eredità nel nostro programma, possiamo anche eseguire il concatenamento dei costruttori. In questo caso, la sottoclasse chiamerà il costruttore della classe base. Facendo questa sottoclasse, la creazione degli oggetti inizia con l'inizializzazione dei membri della superclasse.

Ora implementeremo il concatenamento del costruttore in Java utilizzando gli approcci sopra.

# 1) Concatenamento di costruttori all'interno della stessa classe

come trovare la chiave di sicurezza di rete sul telefono Android

class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } }

Produzione:

concatenamento all

Come già accennato, otteniamo il concatenamento dei costruttori all'interno della stessa classe utilizzando la parola chiave 'this'. Nel programma precedente, abbiamo tre costruttori e chiamiamo un costruttore da un altro utilizzando la parola chiave 'this'.

Dalla classe base

Quando una classe eredita un'altra classe, il costruttore della classe genitore viene richiamato per primo quando creiamo un oggetto di una classe derivata che è il concatenamento del costruttore.

Se vogliamo chiamare esplicitamente il costruttore della classe base nella classe derivata, dovremmo usare la parola chiave 'super' per questo scopo. Utilizzando la parola chiave 'super' possiamo chiamare i costruttori della superclasse nella gerarchia di ereditarietà fino a raggiungere la classe più alta.

Il programma seguente mostra l'uso di una parola chiave 'super' per il concatenamento dei costruttori.

class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }

Produzione:

Dalla classe base

Nel programma sopra, si richiama il costruttore parametrizzato della classe derivata con il valore 'Java'. Questo costruttore a sua volta ha una chiamata al costruttore della classe base usando 'super (nome);' che esegue il costruttore parametrizzato della classe base.

Domande frequenti

D # 1) Come si crea un costruttore in Java?

Risposta: Creiamo un costruttore come metodo speciale che ha lo stesso nome del nome della classe. Anche un costruttore non può avere un tipo restituito. Può avere modificatori di accesso ma non può essere finale, statico, astratto o sincronizzato.

Se ABC è una classe, possiamo definire il suo costruttore come

ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructor

D # 2) Qual è il vantaggio di un costruttore in Java?

Risposta: Usando il costruttore, possiamo inizializzare i membri della classe come prima cosa nel momento in cui viene creato l'oggetto. Il costruttore elimina la necessità di chiamare implicitamente metodi normali.

Possiamo eseguire varie attività relative all'inizializzazione, all'avvio di attività, ecc. Nel costruttore poiché i costruttori vengono richiamati durante la fase di creazione dell'oggetto.

D # 3) Perché vengono utilizzati i costruttori?

Risposta: I costruttori vengono utilizzati principalmente per inizializzare i membri della classe e vengono richiamati quando viene creato l'oggetto della classe.

D # 4) Constructor può essere privato?

Risposta: Sì, possiamo avere un costruttore privato. Quando il costruttore è privato, è possibile impedire la creazione di istanze della classe.

D # 5) Constructor può essere definitivo?

Risposta: No, non possiamo avere un costruttore finale.

Conclusione

In questo tutorial, abbiamo iniziato la nostra discussione sui costruttori in Java. Abbiamo appreso le basi del costruttore, la sua creazione e le regole da seguire. Abbiamo anche discusso dei costruttori di copie in Java.

Il costruttore predefinito e i tipi di costruttori e concetti come il sovraccarico del costruttore e il concatenamento dei costruttori sono stati illustrati con esempi. Come parte di questi argomenti, abbiamo anche visto l'uso della parola chiave 'this' nei costruttori.

=> Leggere attraverso la serie di formazione Easy Java.

Costruttore Java - Costruttori di classe, copia e predefiniti