Super nøkkelord i Java

Nøkkelordsuperen brukes i arven etter Java -klasser. I Java er superklassen overordnet klasse i en nåværende klasse. Den nåværende klassen er barneklassen (underklassen) i superklassen. Det er muligheten for at barnebarnet og oldebarnskursene går nedover. Foreldreklassen er den direkte superklassen i den nåværende klassen. Besteforelderklassen er ikke den direkte superklassen i den nåværende klassen. Denne artikkelen forklarer bruken av nøkkelordet, super i java. Det begynner med å presentere en foreldreklasse, et barn av foreldreklassen og et barnebarn til foreldreklassen. Så viser det hvordan ordet, super, passer inn i hierarkiet. Hierarkiet nedenfor danner en form for kalkulatoren.

Artikkelinnhold

• Tilbakekalling av Java -arv
• Bruk av supernøkkelordet
• Konklusjon

Tilbakekalling av Java -arv

Tenk på følgende klasse:

klasse cparent
int a;
int b;
int add ()
returner A + B;

Denne klassen har to egenskaper: A og B. I Java kalles egenskaper felt. Denne klassen har en metode som legger til to tall, som er feltverdiene. Navnet på klassen er sele, med foregående C, for kalkulator. Følgende kodesegment i Main () -metoden, utganger 5:

Cparent Parent = new Cparent ();
foreldre.a = 2;
foreldre.B = 3;
int radd = foreldre.Legg til();
System.ute.println (radd);

Tenk på følgende klasse, som er underklassen i ovennevnte klasse (cparent):

Klasse cild utvider cparent
int c;
int multiply ()
returner en * c;

Merk bruken av nøkkelordet utvides. Denne klassen har feltet, C og metoden, Multiply (). Klassen arver feltene, 'A' og B, og metoden, legg til (). Imidlertid, hvis feltverdien for 'A' eller B skal brukes til dette nåværende instantierte objektet (barneobjekt), må det fortsatt tilordnes en verdi. For denne klassen multipliseres verdien av 'A' arvet med klassens feltverdi på C. Navnet på denne klassen er Cild, med foregående C, for kalkulator. Følgende kodesegment i Main () -metoden passer til denne klassen:

Cild child = new cild ();
barn.a = 2;
barn.C = 4;
int rmult = barn.multiplisere();
System.ute.Println (RMULT);

Utgangen er 8. Merk at selv om feltet 'A' ble arvet, måtte det fremdeles tilordnes en verdi; I dette tilfellet samme verdi.

Tenk på følgende klasse, som er underklassen i klassen ovenfor, Cild:

Klasse CgrandChild utvider Cild
int d;
int Divide ()
Returner A / D;

Merk bruken av nøkkelordet utvides. Denne klassen har feltet, D og metoden, deling (). Klassen arver medlemmene, 'A', B, og Add () fra Cild -klassen, som arvet dem fra CPARTEN -klassen. Det arver også medlemmene, C og Multiply () fra Cild -klassen. Imidlertid, hvis feltverdien for 'A' eller B eller C, fra foreldre- eller besteforeldreklasser, skal brukes til dette nåværende instantierte objektet (barnebarnsobjekt), må det fremdeles tilordnes en verdi. For denne klassen er verdien av 'A' arvet delt av klassens feltverdi på D. Navnet på denne klassen er Cgrandchild, med foregående C, for kalkulator. Følgende kodesegment i Main () -metoden passer til denne klassen:

Cgrandchild gchild = new CgrandChild ();
gildring.a = 2;
gildring.d = 2;
Int RDIV = Gild.dele opp();
System.ute.println (rdiv);

Utgangen er 1. Merk at selv om feltet 'A' ble arvet, måtte det fremdeles tilordnes en verdi; I dette tilfellet samme verdi, 2.

Bruk av supernøkkelordet

Felt og super
I programmet ovenfor ble verdien for feltet, 'A' satt tre ganger, en gang for overordnede objekt, en gang for barneobjektet, og en gang for barnebarnsobjektet. For å unngå denne tilbakestillingen hver gang, kan verdien av 2 tildeles en gang, i foreldreklasseimplementeringen (definisjon) som følger:

klasse cparent
int a = 2;
int b;
int add ()
returner A + B;

Dette løser problemet med å tilbakestille for hvert etterkommerobjekt. I etterkommerklassene blir feltet, 'a' ganske enkelt referert til (normalt).

For å få tilgang til verdien av et arvelig felt, må supernøkkelordet brukes i etterkommerklasseimplementeringen av interesse, som følger:

super.feltnavn

Følgende kodesegment viser hvordan navnet 'A' har blitt åpnet, i en ny Cild -implementering:

Klasse cild utvider cparent
int p = super.en;
int c;
int multiply ()
return p * c;

Klassen, Cild, har nå sitt eget navn, P i stedet for 'A'. Og så uttalelsen i ADD () -metoden,

returner en * c;

er nå,

return p * c;

På en lignende måte kan klasseimplementeringen, Cgrandchild kan ha 'A' erstattet av Q, som følger:

Klasse CgrandChild utvider Cild
int q = super.en;
int d;
int Divide ()
return q / d;

Merk: Arv finner sted i alle etterkommerklasser. 'A' -feltet og ADD () -metoden arves i Cild -klassen og til CgrandChild -klasse.

Metode og super
Tilsvarende kan det nås et arvelig felt ved implementeringen av en etterkommerklasse; En arvelig metode kan også nås i en etterkommerklasse ved å bruke super nøkkelordet. Syntaksen er:

super.MethodName ()

Implementeringen av den opprinnelige Cild -klassen kan endres som følger:

Klasse cild utvider cparent
int c;
int sum = super.Legg til();
int multiply ()
returner en * c;

Legg merke til at bruk av super. Den arvelige add () -metoden blir nå sett på som en "sum" i implementeringen av Cild. Feltet C, og metoden, Multiply (), er fremdeles der. Et kodesegment for tillegg i Main () -metoden som passer til denne modifiserte Cild -klassen er:

Cild child = new cild ();
int rsum = barn.sum;
System.ute.println (rsum);

Utgangen er 5, forutsatt at foreldreklassen ble endret med:

int a = 2;
int b = 3;

Konstruktør og super
Standardkonstruktøren, som ikke er implementert, arves i hver etterkommerklasse og trenger ikke å redegjøres for i implementeringen av etterkommerne og i Main () -metoden. Når en foreldreklasse har en tilpasset konstruktør, må imidlertid resten av etterkommere ha en lignende konstruktør. Tenk på foreldreklassen, med en tilpasset konstruktør, som følger:

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

int add ()
returner A + B;

Feltene 'A' og B er erklært uten oppdrag. Konstruktøren gjør oppgaven. Barneklassen må ha den samme eller en lignende konstruktør. Den tilsvarende barneklassen for det originale kalkulatorhierarkiet kan være:

Klasse cild utvider cparent
Cild (int x, int y)
Super (x, y);

int c;
int multiply ()
returner en * c;

Konstruktøren her er den samme som foreldrenes. Konstruktørens kropp her har bare:

Super (x, y);

som bare kaller konstruktøren til forelderen, med mottatte argumenter. “Super” her representerer foreldreklassekonstruktøren. Dette er en annen bruk av super. Det er ingen modifisering i denne barnekonstruktøren. Den tilsvarende barnebarnsklassen for det originale kalkulatorhierarkiet kan være:

Klasse CgrandChild utvider Cild
int d;
Cgrandchild (int x, int y, int z)
Super (x, y);
d = z;

int Divide ()
Returner A / D;

Konstruktøren her er endret. Den har de samme x- og y -parametrene og en ekstra parameter, z. z er å tilordne verdien for d, divisoren. Kroppen for konstruktøren begynner med å ringe konstruktøren til foreldreklassen. Da tildeles feltet for divisoren. Følgende kodesegment i Main () -metoden passer til denne klassen:

Cgrandchild gchild = new Cgrandchild (2, 3, 2);
Int RDIV = Gild.dele opp();
System.ute.println (rdiv);

Utgangen for dette er 1.

Konklusjon

Super vil se etter noe i den umiddelbare foreldreklassen. Hvis den ikke ser det der, vil den se etter det i besteforeldreklassen. Hvis den ikke ser det der, vil den se etter det i oldeforeldrensklassen; Og så videre, til den enten ser det eller det ikke ser det. "Super" brukes vanligvis innen implementeringen av en underklasse. Det brukes til felt, metode og konstruktør. Den direkte superklassen er overordnet klasse. Besteforelderklassen er en superklasse, men ikke den direkte superklassen. Deretter skal leseren forstå bruken av "super" med nestede klasser - se senere.