Cos'è Constructor in Java?
CONSTRUCTOR è un metodo speciale utilizzato per inizializzare un oggetto appena creato e viene chiamato subito dopo l'allocazione della memoria per l'oggetto. Può essere utilizzato per inizializzare gli oggetti sui valori desiderati o sui valori predefiniti al momento della creazione dell'oggetto. Non è obbligatorio per il programmatore scrivere un costruttore per una classe.
Se per una classe non viene fornito alcun costruttore definito dall'utente, il compilatore inizializza le variabili membro sui valori predefiniti.
- i tipi di dati numerici sono impostati su 0
- i tipi di dati char sono impostati su un carattere nullo ('\ 0')
- le variabili di riferimento sono impostate su null
In questo tutorial imparerai-
- Regole per la creazione di un costruttore
- Sovraccarico del costruttore in Java
- Constructor Chaining
Regole per la creazione di un costruttore Java
- Ha lo stesso nome della classe
- Non dovrebbe restituire un valore nemmeno nullo
Esempio 1 : crea il tuo primo costruttore in Java
Passaggio 1) Digitare il seguente programma di costruzione nell'editor Java.
class Demo{int value1;int value2;Demo(){value1 = 10;value2 = 20;System.out.println("Inside Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();d1.display();}}
Passaggio 2) Salva, esegui e compila il programma di costruzione in Java e osserva l'output.
Produzione:
Inside ConstructorValue1 === 10Value2 === 20
Sovraccarico del costruttore in Java
Il sovraccarico di Java Constructor è una tecnica in cui una classe può avere un numero qualsiasi di costruttori che differiscono per l'elenco dei parametri. Il compilatore differenzia questi costruttori tenendo conto del numero di parametri nell'elenco e del loro tipo.
Esempi di costruttori validi per la classe Account sono
Account(int a);Account (int a,int b);Account (String a,int b);
Esempio 2 : comprendere il sovraccarico del costruttore in Java
Passaggio 1) Digita il codice nell'editor.
class Demo{int value1;int value2;/*Demo(){value1 = 10;value2 = 20;System.out.println("Inside 1st Constructor");}*/Demo(int a){value1 = a;System.out.println("Inside 2nd Constructor");}Demo(int a,int b){value1 = a;value2 = b;System.out.println("Inside 3rd Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();Demo d2 = new Demo(30);Demo d3 = new Demo(30,40);d1.display();d2.display();d3.display();}}
Passaggio 2) Salva, compila ed esegui il codice.
Passaggio 3) Errore =?. Prova a eseguire il debug dell'errore prima di procedere al passaggio successivo del sovraccarico del costruttore Java
Passaggio 4) Ogni classe ha un costruttore predefinito in Java. Il costruttore predefinito sovraccarico Java per la classe Demo è Demo () . Nel caso in cui non si fornisca questo costruttore, il compilatore lo crea per te e inizializza le variabili ai valori predefiniti. Puoi scegliere di sovrascrivere questo costruttore predefinito e inizializzare le variabili sui valori desiderati come mostrato nell'Esempio 1.
Ma se si specifica un costruttore parametrizzato come Demo (int a) e si desidera utilizzare il costruttore predefinito Java Demo (), è obbligatorio specificarlo.
In altre parole, nel caso in cui il costruttore in sovraccarico in Java venga sovrascritto e si desideri utilizzare il costruttore predefinito Java, è necessario specificarlo.
Passaggio 5) Rimuovere il commento dalla riga # 4-8. Salva, compila ed esegui il codice.
Constructor Chaining
Considera uno scenario in cui una classe base viene estesa da un bambino. Ogni volta che viene creato un oggetto della classe figlia, viene richiamato per primo il costruttore della classe genitore. Questo si chiama concatenamento Costruttore.
Esempio 3: comprendere il concatenamento dei costruttori
Passaggio 1) Copia il seguente codice nell'editor.
class Demo{int value1;int value2;Demo(){value1 = 1;value2 = 2;System.out.println("Inside 1st Parent Constructor");}Demo(int a){value1 = a;System.out.println("Inside 2nd Parent Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){DemoChild d1 = new DemoChild();d1.display();}}class DemoChild extends Demo{int value3;int value4;DemoChild(){//super(5);value3 = 3;value4 = 4;System.out.println("Inside the Constructor of Child");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);System.out.println("Value1 === "+value3);System.out.println("Value2 === "+value4);}}
Passaggio 2) Esegui il codice. A causa del concatenamento dei costruttori, quando viene creato l'oggetto della classe figlia DemoChild, viene richiamato per primo il costruttore Demo () della classe genitore e successivamente viene creato il costruttore DemoChild () del figlio. Uscita prevista =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Passaggio 3) È possibile osservare che il costruttore della classe genitore Demo viene sovrascritto. E se volessi chiamare il costruttore sovrascritto Demo (int a) invece del costruttore predefinito Demo () quando viene creato il tuo oggetto figlio?
In questi casi, è possibile utilizzare la parola chiave "super" per chiamare i costruttori sovrascritti della classe genitore.
Sintassi:-
super();--or--super(parameter list);
Esempio: se il tuo costruttore è come Demo (String Name, int a) specificherai super ("Java", 5) Se usata, la parola chiave super deve essere la prima riga di codice nel costruttore della classe figlia.
Passaggio 4) Rimuovere il commento dalla riga 26 ed eseguire il codice. Osserva l'output.
Produzione:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4