Parola chiave in Java

La parola chiave super viene utilizzata nell'eredità delle classi Java. In Java, la superclasse è la classe principale di una classe corrente. La classe attuale è la classe figlio (sottoclasse) della superclasse. C'è la possibilità delle classi di nipote e pronipote che scendono verso il basso. La classe principale è la superclasse diretta della classe corrente. La classe nonna non è la superclasse diretta della classe attuale. Questo articolo spiega l'uso della parola chiave, super in java. Inizia presentando una classe genitore, un figlio della classe genitore e un nipote della classe madre. Quindi mostra come la parola, super, si adatta alla gerarchia. La gerarchia sotto forma una forma del calcolatore.

Contenuto dell'articolo

• Ricordiamo dell'eredità di Java
• Uso della parola chiave super
• Conclusione

Ricordiamo dell'eredità di Java

Considera la seguente classe:

class cparent
int a;
int b;
int add ()
restituire a + b;

Questa classe ha due proprietà: A e B. In Java, le proprietà sono chiamate campi. Questa classe ha un metodo che aggiunge due numeri, che sono i valori del campo. Il nome della classe è CPARENT, con la precedente C, per la calcolatrice. Il seguente segmento di codice nel metodo principale (), emette 5:

CParent genitore = new cParent ();
genitore.a = 2;
genitore.b = 3;
int radd = genitore.aggiungere();
Sistema.fuori.println (radd);

Considera la seguente classe, che è la sottoclasse della classe sopra (CParent):

Class cchild estende cParent
int c;
int multiply ()
restituire un * c;

Nota l'uso della parola chiave si estende. Questa classe ha il campo, C e il metodo, multiply (). La classe eredita i campi, 'a' e b e il metodo, aggiungi (). Tuttavia, se il valore del campo per "A" o B deve essere utilizzato per questo oggetto istanziato attuale (oggetto figlio), deve ancora essere riassegnato un valore. Per questa classe, il valore di "A" ereditato viene moltiplicato per il valore di campo della classe di C. Il nome di questa classe è cchild, con la precedente C, per la calcolatrice. Il seguente segmento di codice nel metodo principale () si adatta a questa classe:

CChild Child = new CChild ();
bambino.a = 2;
bambino.c = 4;
int rmult = Child.moltiplicare();
Sistema.fuori.println (rmult);

L'output è 8. Si noti che, sebbene il campo "A" fosse ereditato, doveva ancora essere riassegnato un valore; In questo caso, lo stesso valore.

Considera la seguente classe, che è la sottoclasse della classe sopra, CCHILD:

Class CGrandChild estende cchild
int d;
int divide ()
restituire A / D;

Nota l'uso della parola chiave si estende. Questa classe ha il campo, d e il metodo, divide (). La classe eredita i membri, 'A', B e Aggiungi () dalla classe CCHILD, che li ha ereditati dalla classe CParent. Eredita anche i membri, C e Multiply () dalla classe CCHILD. Tuttavia, se il valore di campo per "A" o B o C, dalle classi genitore o nonno, deve essere utilizzato per questo oggetto istanziato attuale (oggetto nipote), deve ancora essere riassegnato un valore. Per questa classe, il valore di "A" ereditato è diviso per il valore di campo della classe di D. Il nome di questa classe è cgrandchild, con la precedente C, per il calcolatore. Il seguente segmento di codice nel metodo principale () si adatta a questa classe:

Cgrandchild gchild = new cgrandchild ();
Gchild.a = 2;
Gchild.d = 2;
int rdiv = gchild.dividere();
Sistema.fuori.println (rdiv);

L'output è 1. Si noti che, sebbene il campo "A" fosse ereditato, doveva ancora essere riassegnato un valore; In questo caso, lo stesso valore, 2.

Uso della parola chiave super

Campo e super
Nel programma sopra, il valore per il campo, "A" è stato impostato tre volte, una volta per l'oggetto genitore, una volta per l'oggetto figlio e una volta per l'oggetto nipote. Per evitare questo ripristino ogni volta, il valore di 2 può essere assegnato una volta, nell'implementazione della classe genitore (definizione) come segue:

class cparent
int a = 2;
int b;
int add ()
restituire a + b;

Ciò risolve il problema del ripristino per ogni oggetto discendente. Nelle classi discendenti, il campo, "a" viene semplicemente indicato (normalmente).

Per accedere al valore di un campo ereditario, la parola chiave deve essere utilizzata nell'attuazione della classe discendente di interesse, come segue:

super.fieldname

Il seguente segmento di codice mostra come è stato accesso il nome "A", in una nuova implementazione CCHILD:

Class cchild estende cParent
int p = super.UN;
int c;
int multiply ()
restituire p * c;

La classe, Cchild, ora ha il suo nome, P invece di "A". E quindi l'affermazione nel metodo Add (),

restituire un * c;

è ora,

restituire p * c;

Allo stesso modo, l'implementazione della classe, CgrandChild può avere "un" sostituito da Q, come segue:

Class CGrandChild estende cchild
int q = super.UN;
int d;
int divide ()
restituire q / d;

Nota: l'eredità avviene in tutte le classi discendenti. Il metodo "un" campo e add () viene ereditato nella classe CCHILD e nella classe CGrandChild.

Metodo e super
Allo stesso modo, è possibile accedere a un campo ereditato nell'attuazione di una classe discendente; È possibile accedere anche a un metodo ereditato in una classe discendente, utilizzando la parola chiave. La sintassi è:

super.MethodName ()

L'implementazione della classe CCHILD originale può essere modificata come segue:

Class cchild estende cParent
int c;
int sum = super.aggiungere();
int multiply ()
restituire un * c;

Si noti che l'uso di super. Il metodo Add () ereditato è ora visto come una "somma" nell'implementazione di CCHILD. Il campo C e il metodo, multiply (), sono ancora lì. Un segmento di codice per l'aggiunta nel metodo principale () adatto a questa classe CCHILD modificata è:

CChild Child = new CChild ();
int rsum = bambino.somma;
Sistema.fuori.println (rsum);

L'output è 5, supponendo che la classe genitore sia stata modificata con:

int a = 2;
int b = 3;

Costruttore e super
Il costruttore predefinito, che non è implementato, viene ereditato in ogni classe discendente e non deve essere spiegato nell'attuazione dei discendenti e nel metodo principale (). Tuttavia, una volta che una classe genitore ha un costruttore personalizzato, il resto dei suoi discendenti deve avere un costruttore simile. Considera la classe madre, con un costruttore personalizzato, come segue:

class cparent
int a, b;
public cParent (int x, int y)
a = x; b = y;

int add ()
restituire a + b;

I campi di "A" e B sono dichiarati senza incarico. Il costruttore esegue l'incarico. La classe figlio deve avere lo stesso o un costruttore simile. La classe figlio corrispondente per la gerarchia del calcolatore originale può essere:

Class cchild estende cParent
CChild (int x, int y)
super (x, y);

int c;
int multiply ()
restituire un * c;

Il costruttore qui è lo stesso di quello del genitore. Il corpo del costruttore qui ha solo:

super (x, y);

che chiama solo il costruttore del genitore, con gli argomenti ricevuti. "Super" qui rappresenta il costruttore della classe genitore. Questo è un altro uso di super. Non ci sono modifiche in questo bambino costruttore. La classe di nipote corrispondente per la gerarchia del calcolatore originale può essere:

Class CGrandChild estende cchild
int d;
CGrandChild (int x, int y, int z)
super (x, y);
d = z;

int divide ()
restituire A / D;

Il costruttore qui è modificato. Ha gli stessi parametri X e Y e un parametro extra, Z. Z è assegnare il valore per D, il divisore. Il corpo per il costruttore inizia chiamando il costruttore della classe genitore. Quindi viene assegnato il campo per il divisore. Il seguente segmento di codice nel metodo principale () si adatta a questa classe:

Cgrandchild gchild = new cgrandchild (2, 3, 2);
int rdiv = gchild.dividere();
Sistema.fuori.println (rdiv);

L'output per questo è 1.

Conclusione

Super cercherà qualcosa nella classe dei genitori immediati. Se non lo vede lì, lo cercherà nella classe nonna. Se non lo vede lì, lo cercherà nella classe del nonno; e così via, fino a quando non lo vede o non lo vede. "Super" viene solitamente utilizzato all'interno dell'implementazione di una sottoclasse. È usato per campo, metodo e costruttore. La superclasse diretta è la classe genitore. La classe nonna è una superclasse, ma non la superclasse diretta. Successivamente, il lettore dovrebbe capire l'uso di "super" con le classi nidificate - vedi più tardi.