Ipinapakita ng blog na ito ang paggamit at pagpapatupad ng dynamic na binding sa Java.
Paano Gamitin ang Dynamic na Binding sa Java?
Nagbibigay-daan ang dinamikong pagbubuklod ng maluwag na pagkakabit sa pagitan ng mga bagay. Nakakatulong ito sa madaling pagpapalawak ng functionality sa pamamagitan ng pagdaragdag ng mga bagong subclass na nag-o-override ng mga pamamaraan nang hindi binabago ang umiiral na code. Ang dynamic na binding ay malawakang ginagamit para sa runtime na pagpapadala, pangangasiwa ng kaganapan, o mga system ng plugin.
Maglakad tayo sa ilang mga halimbawa para sa isang detalyadong paliwanag:
Halimbawa 1: Pagpapatupad ng Dynamic na Binding
Sa pamamagitan ng paggamit ng dynamic na binding, maaaring payagan ng mga programmer ang mga user na i-customize at i-override ang mga default na gawi upang bumuo ng mga nako-customize na application. Para sa praktikal na pagpapatupad, tingnan natin ang isang halimbawa:
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
pampublikong klase DynBind {
pampublikong static void main ( String [ ] args ) {
Gaming gameType1 = bagong Cricket ( ) ;
Gaming gameType2 = bagong CallofDuty ( ) ;
gameType1.gameType ( ) ;
gameType2.gameType ( ) ;
}
}
klase Gaming {
pampublikong void na uri ng laro ( ) {
System.out.println ( 'Mga Pisikal o Virtual na Laro' ) ;
}
}
class Cricket extend Gaming {
@ I-override
pampublikong void na uri ng laro ( ) {
System.out.println ( 'Ang Cricket ay isang Pisikal na Laro' ) ;
}
}
pinapalawak ng klase ng CallofDuty ang Gaming {
@ I-override
pampublikong void na uri ng laro ( ) {
System.out.println ( 'Ang CallofDuty ay isang Virtual na Laro' ) ;
}
}
Paliwanag ng code sa itaas:
- Una, ang klase ' DynBind ' ay nilikha, at dalawang bagay ng uri ' Paglalaro ” ay ipinahayag.
- Susunod, ang mga bagay na ito ay pinasimulan ng bagong ' Kuliglig 'at' CallofDuty ” objects, ipinapakita ng initialization na ito ang dynamic na binding. Ang uri ng sanggunian ay ' Paglalaro ' ngunit ang aktwal na mga uri ng bagay ay ' Kuliglig 'at' CallofDuty ”, ayon sa pagkakabanggit.
- Ngayon, ang mga bagay na ito ay ginagamit upang tawagan ang ' klase ng laro() ” function sa pamamagitan ng pag-override sa function sa mga child class.
- Pagkatapos, ang magulang ' Paglalaro Ang klase ng ” ay ipinahayag na lumilikha at nagpapasimula ng “ klase ng laro() ” function, na nagpi-print ng dummy text message.
- Susunod, dalawang klase ng bata ang nilikha na may pangalang ' Kuliglig 'at' CallofDuty ”. Ang mga klase na ito ay minana mula sa magulang ' Paglalaro ” klase.
- Pagkatapos nito, ang ' @I-override 'Ang anotasyon ay ginagamit upang i-override ang magulang ' Paglalaro 'mga pamamaraan ng klase na pinangalanang' klase ng laro() ”.
- Sa huli, may ipapakitang ibang dummy na mensahe sa parehong mga pamamaraan na na-override ng klase ng bata.
Pagkatapos ng pagtatapos ng yugto ng pagpapatupad:
Ipinapakita ng output na ang mga dummy na mensahe ng mga klase ng bata ay ipinapakita sa console gamit ang dynamic na binding.
Halimbawa 2: Pagpapatupad ng Multilevel Inheritance
Maaari ding ipatupad ang dynamic na binding para sa paglikha ng multilevel inheritance. Dalawang bloke ng code ng parehong programa tulad ng ipinapakita sa ibaba:
klase Gaming {pampublikong void na uri ng laro ( ) {
System.out.println ( 'Mga Pisikal o Virtual na Laro' ) ;
}
}
class Cricket extend Gaming {
@ I-override
pampublikong void na uri ng laro ( ) {
System.out.println ( 'Ang kuliglig ay isang Pisikal na Laro' ) ;
}
pampublikong void playingFormat ( ) {
System.out.println ( 'May iba't ibang format ng paglalaro ang Cricket' ) ;
}
}
pinapalawak ng klase ng CallofDuty ang Gaming {
@ I-override
pampublikong void na uri ng laro ( ) {
System.out.println ( 'Ang CallofDuty ay isang Virtual na Laro' ) ;
}
pampublikong void gameMode ( ) {
System.out.println ( 'Ang CallofDuty ay may maraming mga mode ng laro' ) ;
}
}
class CricketGame extend Cricket {
pampublikong void gameMode ( ) {
System.out.println ( 'May iisang mode ng laro ang Cricket' ) ;
}
}
Ang klase ng CallofDutyGame ay nagpapalawak ng CallofDuty {
}
Paliwanag ng code sa itaas:
- Una, ang magulang' Paglalaro Ang klase ay nilikha at kasama dito ang ' klase ng laro() ” function na naglalaman ng dummy na mensahe.
- Susunod, dalawang klase ng bata na pinangalanang ' Kuliglig 'at' CallofDuty ' ay nilikha, na parehong nag-o-override sa parent class function na pinangalanang ' klase ng laro() ”.
- Ang mga klaseng ito ay naglalaman ng isang karagdagang function na pinangalanang ' playingFormat() 'at' gameMode() ” function, ayon sa pagkakabanggit.
- Pagkatapos, gumawa ng multi-level na bata na may pangalang ' CricketGame 'pinahaba yan ng bata' Kuliglig ” klase. Naglalaman ito ng ' gameMode() 'function na na-override ng magulang nito' Kuliglig ” klase.
- Pagkatapos nito, ang ' CallofDutyGame 'Ang klase ay nilikha bilang isang bata para sa ' CallofDuty ” klase. Lumilikha ito ng multilevel inheritance at para paganahin ang functionality ng dynamic binding.
Ngayon, ipasok ang ' pangunahing() 'paraan:
pampublikong klase DynBind {pampublikong static void main ( String [ ] args ) {
CallofDutyGame codg = bagong CallofDutyGame ( ) ;
codg.gameType ( ) ;
codg.gameMode ( ) ;
CricketGame cricg = bagong CricketGame ( ) ;
cricg.gameType ( ) ;
cricg.playingFormat ( ) ;
cricg.gameMode ( ) ;
}
}
Paliwanag ng code sa itaas:
- Una, isang bagay ng ' CallofDutyGame ” class ay nilikha na tumatawag sa mga function ng mga parent class nito.
- Sa parehong paraan, ang ' CricketGame ” object ay idineklara na tumatawag sa parent class function nito na available sa multilevel sa hierarchy.
Pagkatapos ng pagtatapos ng yugto ng pagpapatupad:
Ipinapakita ng output na ang multilevel inheritance ay nilikha gamit ang dynamic na binding sa Java.
Konklusyon
Sa Java, ang ' dinamikong pagbubuklod ” ay nag-aalok ng mga benepisyo gaya ng polymorphism, code reusability, flexibility, at extensibility. Ito ay ipinapatupad sa pamamagitan ng pagsunod sa mga tuntunin ng pamana, paraan ng pag-override, at upcasting. Ang dynamic na binding ay nagbibigay-daan din sa mga function ng runtime at pinapahusay ang flexible at polymorphic na pag-uugali sa konsepto ng mga OOP. Iyon ay tungkol sa paggamit at pagpapatupad ng dynamic na pagbubuklod sa Java.