I Java är ' sträcker sig ' och ' redskap ” nyckelord är avgörande för att effektivt integrera flera funktioner. Till exempel att ärva de redan tilldelade funktionerna för att uppdatera dem eller sortera ut data på lämpligt sätt. I sådana fall är nyckelorden 'förlänger' och 'implementerar' till hjälp för att göra saker bekväma i utvecklarens ände och hantera resurserna effektivt.
Den här bloggen kommer att belysa skillnaderna mellan Java 'extends' och 'implements'.
Java 'förlänger' nyckelord
Java ' sträcker sig ' nyckelord används av en barnklass, dvs. ' härledd ' för att ärva den överordnade klassen, dvs. ' bas ” genom att komma åt dess funktioner.
Syntax
klass A {
// kropp
}
klass B sträcker sig A {
// kropp
}
I den här syntaxen ' B ' motsvarar den underordnade klassen som ärver förälderklassen ' A ' via ' sträcker sig ' nyckelord.
Exempel 1: Använda nyckelordet 'extends' i Java
Detta exempel använder ' sträcker sig ' nyckelord för att ärva föräldern, dvs. ' bas ' klass:
klass Föräldraklass {Sträng x = 'Hår' ;
}
klass barnklass utökar föräldraklass {
offentlig String konkat ( ) {
lämna tillbaka x.concat ( 'ry' ) ;
} }
offentlig klass Förlänger {
offentliga statiska tomrum huvud ( String args [ ] ) {
barnklassobjekt = ny barnklass ( ) ;
System.out.println ( object.concat ( ) ) ;
} }
Följ följande steg enligt ovanstående kodavsnitt:
- Först deklarera en föräldraklass som heter ' Föräldraklass ”.
- Initiera den angivna variabeln i dess definition.
- Ärv nu en barnklass från föräldraklassen via ' sträcker sig ' nyckelord.
- I den underordnade klassdefinitionen, definiera en funktion som heter ' concat() ”.
- I funktionsdefinitionen, anropa variabeln från den överordnade klassen och lägg till den angivna strängen via den associerade ' concat() 'metoden.
- I ' main() '-metoden, skapa ett underordnat klassobjekt med hjälp av ' ny ' nyckelord och ' barnklass() ” konstruktör.
- Till sist, anropa funktionen barnklass ' concat() ” via det skapade objektet.
Produktion
I denna utgång kan det visualiseras att föräldraklassfunktionaliteten, dvs. variabel(x) ” ärvs på lämpligt sätt via nyckelordet ”extends” och så sammanfogas strängen därefter.
Java 'implementerar' nyckelord
den ' redskap ” nyckelord används för att implementera ett gränssnitt i klassen från samma eller en extern fil.
Syntax
offentligt gränssnitt InterfaceName {ogiltig x ( ) ;
default void y ( ) {
// kropp
}
}
klass z implementerar InterfaceName {
// klasskropp
}
I denna syntax:
- ' x ” hänvisar till en abstrakt metod.
- ' och ” indikerar standardmetoden.
- ' klass z ' motsvarar klassen som implementerar ' Gränssnittsnamn '-gränssnittet via ' redskap ' nyckelord.
Exempel 2: Använda nyckelordet 'implementerar' i Java
I detta specifika exempel, ett gränssnitt som består av ' abstrakt ' och ' standard ”-metoder kan implementeras i klassen.
Gränssnittskod
ålder för offentliga gränssnitt {offentligt ogiltiga namn ( ) ;
standard ogiltig DOB ( ) {
System.out.println ( 'DOB -> 28/8/1999' ) ;
} }
I ovanstående gränssnittskod, inkludera en abstrakt metod med namnet ' namn() ' och definiera standardmetoden ' DOB() ” skriver ut det angivna meddelandet.
Klasskod
Fortsätt nu till följande kodrader:
klassprov implementerar ålder {offentligt ogiltiga namn ( ) {
System.out.println ( 'Namn -> David' ) ;
} }
offentlig klass gränssnitt2 {
offentliga statiska tomrum huvud ( String args [ ] ) {
provobjekt = nytt prov ( ) ;
objekt.namn ( ) ;
objekt.DOB ( ) ;
} }
I detta kodblock:
- Definiera en klass som heter ' prov 'implementera gränssnittet' ålder ' via ' redskap ' nyckelord.
- I dess (klass) definition, definiera den abstrakta metoden ' namn() ” anges i gränssnittet som visar det angivna namnet.
- I ' main() ”-metoden, skapa ett klassobjekt via det diskuterade tillvägagångssättet.
- Slutligen, åberopa abstrakt och standardmetoder med hjälp av det skapade objektet, respektive.
Produktion
Detta resultat innebär att standardmetoden anropas och den abstrakta metoden tillämpas på lämpligt sätt baserat på det implementerade gränssnittet.
Kärnskillnader mellan 'extends' och 'implementerar' i Java
Följande är några av kärnskillnaderna mellan 'extends' och 'implements' nyckelorden i Java:
| sträcker sig | redskap |
| Detta nyckelord kan användas av en klass för att ärva sin överordnade klass eller ett gränssnitt för att ärva andra gränssnitt. | En klass kan implementera gränssnittet via nyckelordet 'implementerar'. |
| Endast en förälderklass kan utökas med en klass. | En klass kan implementera/tillämpa flera gränssnitt samtidigt. |
| Det är inte obligatoriskt för en barnklass som utökar en föräldraklass att åsidosätta alla metoder i en föräldraklass. | Det är obligatoriskt att en klass som implementerar ett gränssnitt måste implementera/tillämpa alla gränssnittsmetoder också. |
Slutsats
den ' sträcker sig ' nyckelord kan användas av en klass eller ett gränssnitt för att ärva dess överordnade klass eller andra gränssnitt, medan ' redskap ” nyckelord används av en klass för att implementera ett gränssnitt. Den här bloggen visade skillnaderna mellan 'extends' och 'implementerar' i Java med hjälp av praktiska exempel.