A Giava, concatenamento del costruttore è una sequenza di invocazioni costruttori all'inizializzazione di un oggetto. Si usa quando vogliamo invocare più costruttori, uno dopo l'altro utilizzando solo un'istanza. In questa sezione discuteremo concatenamento di costruttori in Java in dettaglio con esempi appropriati. Diamo una rapida occhiata a cos'è un costruttore in Java.
Costruttore
In Giava , un costruttore è uguale a un metodo ma l'unica differenza è che il costruttore ha lo stesso nome del nome della classe. Viene utilizzato per creare un'istanza della classe. Viene chiamato automaticamente quando creiamo un oggetto della classe. Non ha un tipo di reso. Ricorda che un costruttore non può esserlo astratto , finale , sincronizzato , E statico . Non possiamo sovrascrivere un costruttore.
In Java esistono due tipi di costruttori:
- Costruttore predefinito (noto anche come costruttore senza argomenti)
- Costruttore parametrizzato
Concatenamento del costruttore
Nella catena di costruttori, un costruttore viene chiamato da un altro costruttore nella stessa classe come è noto questo processo concatenamento del costruttore. Avviene attraverso l'ereditarietà. Quando creiamo un'istanza di una classe derivata, vengono prima invocati tutti i costruttori della classe ereditata (classe base), dopodiché viene invocato il costruttore della classe chiamante (classe derivata).
Possiamo ottenere il concatenamento dei costruttori in due modi:
ghiottone contro tasso
Ricorda che la modifica dell'ordine del costruttore non influisce sull'output.
La necessità del concatenamento dei costruttori
Supponiamo che ci siano cinque compiti da eseguire. Esistono due modi per eseguire queste attività: implementare tutte le attività in un singolo costruttore o creare attività separate in un singolo costruttore.
Utilizzando il meccanismo di concatenamento dei costruttori, possiamo implementare più attività in un singolo costruttore. Quindi, ogni volta che affrontiamo questo tipo di problemi, dovremmo usare il concatenamento dei costruttori. Possiamo rendere il programma più leggibile e comprensibile utilizzando il concatenamento dei costruttori.
Regole del concatenamento dei costruttori
- Un'espressione che utilizza Questo la parola chiave deve essere la prima riga del costruttore.
- Deve esistere almeno un costruttore che non utilizza Questo
Costruttore Chiamata da un altro Costruttore
La chiamata del costruttore può essere effettuata in due modi:
Nota: nello stesso blocco costruttore, non possiamo usare this() e super() contemporaneamente.
Comprendiamo questi due concetti attraverso i programmi Java.
tipi di ciclo for
Esempi di concatenamento di costruttori
Chiamata al costruttore della classe corrente
Noi usiamo Questo() parola chiave se vogliamo chiamare il costruttore della classe corrente all'interno della stessa classe. L'uso di this() è obbligatorio perché JVM non metterlo mai automaticamente come il super() parola chiave. Nota che this() deve essere la prima riga del costruttore. Deve esistere almeno un costruttore senza parola chiave this() .
Sintassi:
this(); or this(parameters list);
Per esempio:
this(); this('Javatpoint');
Creiamo un programma Java e chiamiamo il costruttore della classe corrente.
CostruttoreChain.java
public class ConstructorChain { //default constructor ConstructorChain() { this('Javatpoint'); System.out.println('Default constructor called.'); } //parameterized constructor ConstructorChain(String str) { System.out.println('Parameterized constructor called'); } //main method public static void main(String args[]) { //initializes the instance of example class ConstructorChain cc = new ConstructorChain(); } } Produzione:
nuova linea Python
Nell'esempio precedente, abbiamo creato un'istanza della classe senza passare alcun parametro. Per prima cosa chiama il costruttore predefinito e il costruttore predefinito reindirizza la chiamata a quello parametrizzato a causa di this(). Le istruzioni all'interno del costruttore con parametri vengono eseguite e ritornano al costruttore predefinito. Successivamente, viene eseguito il resto delle istruzioni nel costruttore predefinito e l'oggetto viene inizializzato con successo. Quella che segue è la sequenza di chiamate del costruttore:
ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()
Chiamata al costruttore di superclassi
A volte, dobbiamo chiamare il costruttore della superclasse (classe genitore) dalla classe figlia (classe derivata). In questi casi utilizziamo la parola chiave super() nel costruttore della classe derivata. È facoltativo scrivere super() perché JVM lo inserisce automaticamente. Dovrebbe essere sempre scritto nella prima riga. Otteniamo un errore di sintassi se proviamo a chiamare un costruttore di superclasse nella classe figlia.
Sintassi:
super(); or super(Parameter List);
super(): Chiama il costruttore senza argomenti o predefinito della superclasse.
stringa java contiene
super(parametri): Richiama il costruttore parametrizzato della superclasse.
Ricordare che il costruttore della superclasse non può essere ereditato nella sottoclasse. Può essere chiamato dal costruttore della sottoclasse utilizzando la parola chiave super.
Creiamo un programma Java e implementiamo il concatenamento del costruttore in una classe ereditata.
CostruttoreChaining.java
//parent class or base class class Demo { //base class default constructor Demo() { this(80, 90); System.out.println('Base class default constructor called'); } //base class parameterized constructor Demo(int x, int y) { System.out.println('Base class parameterized constructor called'); } } //derived class or child class class Prototype extends Demo { //derived class default constructor Prototype() { this('Java', 'Python'); System.out.println('Derived class default constructor called'); } //derived class parameterized constructor Prototype(String str1, String str2) { super(); System.out.println('Derived class parameterized constructor called'); } } public class ConstructorChaining { //main method public static void main(String args[]) { //initializes the instance of example class Prototype my_example = new Prototype(); } } Produzione:
