Den här bloggen demonstrerar användningen och implementeringen av dynamisk bindning i Java.
Hur man använder dynamisk bindning i Java?
Dynamisk bindning möjliggör lös koppling mellan objekt. Det hjälper till att enkelt utöka funktionaliteten genom att lägga till nya underklasser som åsidosätter metoder utan att ändra befintlig kod. Dynamisk bindning används i stor utsträckning för körtidsutskick, händelsehantering eller plugin-system.
Låt oss gå igenom ett par exempel för en detaljerad förklaring:
Exempel 1: Implementering av dynamisk bindning
Genom att använda dynamisk bindning kan programmerare tillåta användare att anpassa och åsidosätta standardbeteenden för att bygga anpassningsbara applikationer. För praktisk implementering, låt oss gå igenom ett exempel:
importera java.util.Arrays;
importera java.util.HashSet;
importera java.util.List;
importera java.util.Set;
offentlig klass DynBind {
offentliga statiska tomrum huvud ( Sträng [ ] args ) {
Gaming gameType1 = ny Cricket ( ) ;
Gaming gameType2 = nya CallofDuty ( ) ;
gameType1.gameType ( ) ;
gameType2.gameType ( ) ;
}
}
klass spel {
public void gameType ( ) {
System.out.println ( 'Fysiska eller virtuella spel' ) ;
}
}
klass Cricket utökar Gaming {
@ Åsidosätta
public void gameType ( ) {
System.out.println ( 'Cricket är ett fysiskt spel' ) ;
}
}
klass CallofDuty utökar Gaming {
@ Åsidosätta
public void gameType ( ) {
System.out.println ( 'CallofDuty är ett virtuellt spel' ) ;
}
}
Förklaring av ovanstående kod:
- Först, klassen ' DynBind ” skapas och två objekt av typen ” Spelande ” deklareras.
- Därefter initieras dessa objekt med nya ' Cricket ' och ' CallofDuty '-objekt, visar denna initiering den dynamiska bindningen. Referenstypen är ' Spelande ' men de faktiska objekttyperna är ' Cricket ' och ' CallofDuty ”, respektive.
- Nu används dessa objekt för att anropa ' speltyp() ” fungerar genom att åsidosätta funktionen i barnklasser.
- Sedan, föräldern ' Spelande klass deklareras som skapar och initierar ' speltyp() ”-funktion, som skriver ut ett dummy-textmeddelande.
- Därefter skapas två barnklasser med namnet ' Cricket ' och ' CallofDuty ”. Dessa klasser ärvs från föräldern ' Spelande ' klass.
- Efter det kommer ' @Åsidosätta ' annotering används för att åsidosätta föräldern ' Spelande ' klassmetoder med namnet ' speltyp() ”.
- I slutändan visas ett annat dummymeddelande i båda metoderna som åsidosätts under barnklass.
Efter slutet av utförandefasen:
Utdatan visar att dummy-meddelanden för underordnade klasser visas på konsolen med hjälp av dynamisk bindning.
Exempel 2: Implementering av arv på flera nivåer
Dynamisk bindning kan också implementeras för att skapa flernivåarv. Två kodblock av samma program som visas nedan:
klass spel {public void gameType ( ) {
System.out.println ( 'Fysiska eller virtuella spel' ) ;
}
}
klass Cricket utökar Gaming {
@ Åsidosätta
public void gameType ( ) {
System.out.println ( 'Cricket är ett fysiskt spel' ) ;
}
public void playingFormat ( ) {
System.out.println ( 'Cricket har olika spelformat' ) ;
}
}
klass CallofDuty utökar Gaming {
@ Åsidosätta
public void gameType ( ) {
System.out.println ( 'CallofDuty är ett virtuellt spel' ) ;
}
public void spelläge ( ) {
System.out.println ( 'CallofDuty har flera spellägen' ) ;
}
}
klass CricketGame utökar Cricket {
public void spelläge ( ) {
System.out.println ( 'Cricket har enspelsläge' ) ;
}
}
klass CallofDutyGame utökar CallofDuty {
}
Förklaring av ovanstående kod:
- Först, föräldern ' Spelande '-klassen skapas och den innehåller ' speltyp() ”-funktion som innehåller ett dummymeddelande.
- Därefter två barnklasser som heter ' Cricket ' och ' CallofDuty ' skapas, båda åsidosätter den överordnade klassfunktionen med namnet ' speltyp() ”.
- Dessa klasser innehåller en extra funktion som heter ' playFormat() ' och ' spelläge() ”-funktioner.
- Skapa sedan ett barn på flera nivåer som heter ' Cricketspel ' som förlängs av barnet ' Cricket ' klass. Den innehåller ' spelläge() ' funktion som åsidosätts av sin överordnade ' Cricket ' klass.
- Efter det kommer ' CallofDutyGame ' klass skapas som ett barn för ' CallofDuty ' klass. Det skapar ett arv på flera nivåer och för att möjliggöra funktionaliteten för dynamisk bindning.
Nu sätter du in ' main() ' metod:
offentlig klass DynBind {offentliga statiska tomrum huvud ( Sträng [ ] args ) {
CallofDutyGame codg = nytt CallofDutyGame ( ) ;
codg.gameType ( ) ;
codg.gameMode ( ) ;
Cricketspel cricg = nytt Cricketspel ( ) ;
cricg.gameType ( ) ;
cricg.playingFormat ( ) ;
cricg.gameMode ( ) ;
}
}
Förklaring av ovanstående kod:
- Först, ett föremål för ' CallofDutyGame ” klass skapas som anropar funktionerna för sina överordnade klasser.
- På samma sätt, ' Cricketspel ” objekt deklareras vilket anropar dess överordnade klassfunktion som är tillgänglig på flera nivåer i hierarkin.
Efter slutet av utförandefasen:
Resultatet visar att arv på flera nivåer skapas med hjälp av dynamisk bindning i Java.
Slutsats
I Java är ' dynamisk bindning ” erbjuder fördelar som polymorfism, kodåteranvändbarhet, flexibilitet och utökningsbarhet. Det implementeras genom att följa regler för arv, metodöverstyrning och uppsändning. Dynamisk bindning möjliggör också körtidsfunktioner och förbättrar flexibelt och polymorft beteende i OOPs-konceptet. Det handlar om användningen och implementeringen av dynamisk bindning i Java.