Ang komposisyon ay nagpapahintulot sa mga programmer na muling gamitin ang mga kasalukuyang klase sa pamamagitan ng pagsasama ng mga ito sa mga bagong klase. Sa halip na i-duplicate ang code mula sa maraming klase na nagpapahusay sa muling paggamit ng code. Bukod dito, ang komposisyon ay nagbibigay ng kakayahang umangkop sa pagsasama-sama ng mga bagay batay sa natanggap na mga kinakailangan ng isang klase. Itinataguyod din nito ang modularity at ginagawang mas madaling ibagay ang code sa mga pagbabago.
Ang artikulong ito ay nagpapakita ng isang detalyadong paliwanag ng komposisyon sa Java sa tulong ng mga halimbawa.
Paano Gamitin ang Komposisyon sa Java na may Mga Halimbawa?
Itinataguyod ng komposisyon ang maluwag na pagkakabit sa pagitan ng mga klase. Ang mga binubuong bagay ay ina-access sa pamamagitan ng mga interface, abstract na klase, o super class, na nag-decouple sa klase ng kliyente mula sa mga partikular na pagpapatupad. Pinahuhusay nito ang pagpapanatili ng code at nagbibigay-daan para sa mas madaling pagsubok at refactoring.
Bisitahin ang halimbawa sa ibaba para sa isang mas mahusay na pag-unawa sa komposisyon sa Java:
Halimbawa: Pagpapatupad ng Konsepto ng Komposisyon sa Java
Para sa pagpapatupad ng konsepto ng komposisyon magsimula sa paglikha ng dalawa o higit pang mga klase na nagmamana ng function, at mga pamamaraan upang mabawasan ang oras at pagiging kumplikado ng code tulad ng ipinapakita sa ibaba:
klase Engine {pribadong String uri ;
pampublikong Engine ( String uri ) {
ito.uri = uri ;
}
pampublikong walang bisa simula ( ) {
System.out.println ( uri + 'Nagstart na ang makina' ) ;
}
public void stop ( ) {
System.out.println ( uri + 'Tumigil ang makina' ) ;
}
}
klase Bike {
pribadong String na bersyon;
pribadong Engine engn;
pampublikong Bike ( String na bersyon, Engine engine )
{
this.version = bersyon;
this.engn = engin;
}
pampublikong void startBike ( ) {
System.out.println ( 'Pagsisimula ng bike' + bersyon ) ;
engn.simula ( ) ;
}
pampublikong void stopBike ( ) {
System.out.println ( 'Ihinto ang bike' + bersyon ) ;
engn.stop ( ) ;
}
}
Paliwanag ng code sa itaas:
- Una, lumikha ng isang klase na pinangalanang ' makina ” at i-invoke ang default na constructor na nagdadala ng isang String type na parameter na pinangalanang “ uri ”.
- Susunod, ipahayag ang dalawang function na pinangalanang ' simulan() 'at' stop() ” na nagpi-print ng mga dummy na mensahe sa console.
- Pagkatapos, lumikha ng bagong klase na pinangalanang ' Bike ” at ang default na tagabuo ay ginagamit na naglalaman ng variable at ang object ng klase sa itaas bilang isang parameter.
- Gayundin, itakda ang mga parameter na ito bilang mga halaga para sa mga variable at bagay na ginawa sa loob ng klase ng 'Bike'. Ginagawa nitong naa-access ang mga halaga sa loob ng klase.
- Pagkatapos nito, ang dalawang function ay nilikha na pinangalanang ' startBike() 'at' stopBike() ” na nag-print ng dummy message.
- Sa huli, tinatawag ang mga function na nilikha sa ' makina ” class sa pamamagitan ng paggamit ng object na pinangalanang “ engn ”.
Ngayon, ipasok ang ' pangunahing() 'paraan para gumana ang nakasaad sa itaas na code:
Komposisyon ng pampublikong klase {pampublikong static void main ( String [ ] args ) {
makina Walang sinuman = bagong Engine ( 'YBR' ) ;
Bike bik = bagong Bike ( 'Mabigat na Bike' , Walang sinuman ) ;
bik.startBike ( ) ;
bik.stopBike ( ) ;
}
}
Paliwanag ng code sa itaas:
- Una, ang layunin ng ' makina 'Ang klase ay nilikha gamit ang pangalan' Walang sinuman ” at ang isang random na halaga ng uri ng String ay ipinapasa sa tagabuo nito.
- Susunod, lumikha ng isang bagay para sa ' Bike 'class na pinangalanan' partikular ”. Pagkatapos nito, ipasa ang halaga ng uri ng String sa kahabaan ng object ng klase na 'Engine' bilang argumento sa constructor nito.
- Sa huli, tawagan ang ' startBike() 'at' stopBike() ” function gamit ang “ partikular ” bagay.
Pagkatapos ng pagpapatupad ng snippet ng code sa itaas:
Ang snapshot sa itaas ay nagpapakita na ang data ay nakuha gamit ang konsepto ng komposisyon.
Real-Time na Paggamit ng Komposisyon
Maraming real-time na application kung saan gumaganap ng mahalagang papel ang konsepto ng komposisyon. Ilan sa mga ito
ang mga paggamit ay nakasulat sa ibaba:
- Sa ' Pag-unlad ng GUI ”, ang komposisyon ay karaniwang ginagamit upang bumuo ng mga kumplikadong bahagi ng UI. Halimbawa, ang isang Window class ay maaaring bumuo ng mga bagay tulad ng Button, Label, at Text Field.
- Ang ' Dependency Injection ” frameworks, tulad ng Spring, ay lubos na gumagamit ng komposisyon upang mag-inject ng mga dependency sa mga bagay.
- Ang komposisyon ay malawakang ginagamit sa ' Disenyo ng Application ” para magmodelo ng mga kumplikadong ugnayan sa pagitan ng mga bagay tulad ng Customer, Transaksyon, at Balanse upang kumatawan sa isang bank account na may mga nauugnay na functionality
- Ang komposisyon ay pangunahing sa ' Pag-unlad na Nakabatay sa Bahagi ”, kung saan ang mga bahaging magagamit muli ay binubuo upang lumikha ng mas malalaking sistema.
- Ang komposisyon ay ginagamit sa iba't ibang mga istruktura ng data upang pagsamahin ang mga mas simpleng istruktura ng data upang bumuo ng mga mas kumplikado.
Konklusyon
Ang komposisyon ay ginagamit upang lumikha ng mga kumplikadong bagay sa pamamagitan ng pagsasama-sama ng mga simpleng bagay. Nagbibigay-daan ito sa mga programmer na magtatag ng mga ugnayan sa pagitan ng mga klase batay sa ' mayroong ” relasyon, kung saan ang unang klase ay naglalaman ng isang halimbawa ng pangalawang klase. Sa pamamagitan ng paggamit ng konsepto ng komposisyon, makakamit ng programmer ang modular, magagamit muli, at nababaluktot na mga disenyo sa pamamagitan ng pagbubuo ng mga bagay na may mga partikular na gawi.