IL 'Questo' e il ' super' le parole chiave sono parole riservate che vengono utilizzate in un contesto diverso. Oltre a questo, Java fornisce anche Questo() E super() costruttori utilizzati nel contesto del costruttore. In questa sezione discuteremo di differenze tra questa e la super parola chiave E costruttore this() e super(), a Giava.
parola chiave super e costruttore super()
parola chiave eccellente
Una parola chiave riservata utilizzata per chiamare il metodo o la variabile della classe base è nota come a super parola chiave. Non possiamo usare il super parola chiave come an identificatore . La parola chiave super non viene utilizzata solo per fare riferimento all'istanza della classe base ma anche ai membri statici.
super() Costruttore
IL super() viene utilizzato principalmente per richiamare funzioni membro e costruttori della classe base.
Facciamo un esempio di entrambi i super parola chiave e super() per capire come funzionano.
SuperEsempio1.java
// import required classes and packages package javaTpoint.MicrosoftJava; // create Animal class which is base class of Animal class Animal{ // data member of Animal class String color = 'white'; } // create child class of Animal class Cat extends Animal{ //default constructor Cat() { // data members of the Cat class String color = 'Brown'; System.out.println('The cat is of color '+super.color); // calling parent class data member System.out.println('The cat is of color '+color); } } // create child class for Car class SuperExample1 extendsCat { // default constructor SuperExample1() { // calling base class constructor super(); System.out.println('The eyes of the cat is blue.'); } // main() method start publicstaticvoid main(String[] args) { // call default constructor of the SuperExample1 new SuperExample1(); System.out.println('Inside Main'); } }
Produzione:
Nel metodo main() abbiamo fatto un'istruzione nuovo SuperEsempio1() . Chiama il costruttore di SuperEsempio1 classe.
All'interno del costruttore, abbiamo fatto dichiarazione super() che chiama il costruttore della sua classe genitore, cioè, Gatto. Nel costruttore abbiamo fatto tre affermazioni:
- Inizializza il colore con il valore 'Marrone'.
- Stampa il membro dati della classe genitore.
- Stampa il membro dei dati della classe corrente.
Quando viene eseguita la seconda istruzione, il flusso del programma passa alla classe Animal per accedere al valore dei suoi membri dati. Dopo avervi effettuato l'accesso, il flusso ritorna al file Gatto costruttore della classe e lo stampa. Successivamente, l'ultima istruzione viene eseguita e stampa il valore delle variabili della classe corrente.
Dopo l'esecuzione dell'ultima istruzione del Gatto class, il flusso ritorna al costruttore della classe SuperEsempio1 ed esegue le restanti istruzioni.
Dopo aver completato l'esecuzione del SuperEsempio1() , il flusso ritorna al metodo main() ed esegue le istruzioni rimanenti.
Nota: per poter utilizzare super(), dobbiamo assicurarci che sia la prima istruzione nel costruttore di una classe. Possiamo usarlo per fare riferimento solo al costruttore della classe genitore.
questa parola chiave e il costruttore this()
questa parola chiave
È una parola chiave riservata in Java utilizzata per fare riferimento all'oggetto classe corrente. È una variabile di riferimento attraverso la quale viene chiamato il metodo. Altri usi di questa parola chiave sono:
- Possiamo usarlo per fare riferimento alla variabile dell'istanza della classe corrente.
- Possiamo usarlo per invocare il metodo della classe corrente (implicitamente).
- Possiamo passarlo come argomento nel metodo e nelle chiamate al costruttore.
- Possiamo anche usarlo per restituire l'istanza della classe corrente dal metodo.
this() Costruttore
Il costruttore viene utilizzato per chiamare un costruttore dall'altro della stessa classe. Facciamo un esempio di entrambi Questo parola chiave e Questo() per capire come funzionano.
QuestoEsempio1.java
// import required classes and packages package javaTpoint.MicrosoftJava; // create ThisExample1 class to understand the working of this() and this class ThisExample1 { // initialize instance and static variable int x = 5; staticinty = 10; // default constructor of class ThisExample1 ThisExample1() { // invoking current class constructor this(5); System.out.println('We are insie of the default constructor.'); System.out.println('The value of x = '+x); } ThisExample1(int x) { this.x = x; // override value of the current class instance variable System.out.println('We are inside of the parameterized constructor.'); System.out.println('The value of y = '+y); } publicstaticvoid main(String[] args) { // invoking constructor of the current class new ThisExample1(); System.out.println('Inside Main'); } }
Produzione:
Differenza tra questa e la super parola chiave
La tabella seguente descrive la differenza fondamentale tra questo e super:
Questo | super |
---|---|
L'istanza corrente della classe è rappresentata da questa parola chiave. | L'istanza corrente della classe genitore è rappresentata dalla parola chiave super. |
Per chiamare il costruttore predefinito della classe corrente, possiamo usare questa parola chiave. | Per chiamare il costruttore predefinito della classe genitore, possiamo usare la parola chiave super. |
Può essere riferito da un contesto statico. Significa che può essere invocato dal contesto statico. | Non è possibile farvi riferimento da un contesto statico. Significa che non può essere invocato da un contesto statico. |
Possiamo usarlo per accedere solo ai membri dati della classe corrente e alle funzioni membro. | Possiamo usarlo per accedere ai membri dati e alle funzioni membro della classe genitore. |
Differenza tra il costruttore this() e super()
Questo() | super() |
---|---|
Il costruttore this() si riferisce all'oggetto della classe corrente. | Il costruttore super() fa riferimento all'oggetto classe genitore immediato. |
Viene utilizzato per invocare il metodo della classe corrente. | Viene utilizzato per invocare i metodi della classe genitore. |
Può essere utilizzato ovunque nel costruttore parametrizzato. | È sempre la prima riga nel costruttore della classe figlia. |
Viene utilizzato per invocare una versione di superclasse di un metodo sovrascritto. | Viene utilizzato per invocare una versione di superclasse di un metodo sovrascritto. |