Ang blog na ito ay magdedetalye sa paggawa ng 'refactoring' sa Java.
Paano Gumagana ang Refactoring sa Java?
“ Refactoring ” sa Java ay tumutugma sa pagbabago at pagpapabuti ng istraktura ng code nang hindi binabago ang pag-andar nito, at sa gayon ay na-streamline ang code.
Halimbawa 1: Paglalapat ng Code Functionalities Nang Walang Refactoring sa Java
Sa halimbawang ito, maihahambing ang mga halaga sa pamamagitan ng function na tinukoy ng gumagamit nang walang 'refactoring':
pampubliko klase refactoring {
pampubliko static boolean katumbas ( int pagpipilian1 , int val2 ) {
kung ( pagpipilian1 == val2 ) {
bumalik totoo ;
}
iba pa kung ( pagpipilian1 > val2 || pagpipilian1 < val2 ) {
bumalik mali ;
}
iba pa {
bumalik mali ;
} }
pampubliko static walang bisa pangunahing ( String args [ ] ) {
Sistema. palabas . println ( katumbas ( 2 , 2 ) ) ;
} }
Ayon sa linya ng code sa itaas, ilapat ang mga sumusunod na hakbang:
- Una, tukuyin ang isang function na pinangalanang ' katumbas ng() 'nagkakaroon ng' boolean ” uri ng pagbabalik.
- Ang mga parameter ng function ay tumutugma sa mga naipasa na halaga na kailangang suriin para sa pagkakapantay-pantay.
- Sa kahulugan nito(function), sa “ kung ” pahayag, suriin kung ang mga halaga ay “ pantay ” at ibalik ang kaukulang boolean na kinalabasan.
- Kung hindi, ibalik ang ' mali ” output sa kaso ng mga halaga na mas malaki o mas maliit kumpara sa bawat isa.
- Nasa ' pangunahing() ” paraan, i-invoke ang ipinahayag na function sa pamamagitan ng pagpasa ng magkaparehong halaga bilang mga argumento nito.
Output
Sa output na ito, mapapansin na dahil ang mga halaga ay pantay, ang ' kung ” na pahayag ay na-invoke at ang kaukulang boolean na kinalabasan ay ibinalik.
Halimbawa 2: Refactoring ang Code Functionalities sa Java
Ang sumusunod na halimbawa ay naglalapat ng refactoring sa itaas na code sa pamamagitan ng pagpapasimple nito, sa gayon ginagawa itong maigsi:
pampubliko klase refactoring {
pampubliko static boolean katumbas ( int pagpipilian1 , int val2 ) {
bumalik ( pagpipilian1 == val2 ) ;
}
pampubliko static walang bisa pangunahing ( String args [ ] ) {
Sistema. palabas . println ( katumbas ( 2 , 2 ) ) ;
} }
Sa itaas na bloke ng code:
- Una, ihambing lamang ang mga integer na ipinasa bilang mga argumento ng function at ibalik ang kaukulang ' boolean ” resulta batay sa inilapat na pagsusuri sa pagkakapantay-pantay.
- Ang mga halaga ng boolean ' totoo 'o' mali ” ay bubuo batay sa nasiyahan at hindi nasisiyahang paghahambing, ayon sa pagkakabanggit.
- Panghuli, gayundin ang tawagin ang tinukoy na function sa pamamagitan ng pagpasa sa mga nakasaad na integer na susuriin para sa paghahambing.
Output
Ang output na ito ay nagpapahiwatig na ang ipinatupad na pag-andar, sa nakaraang halimbawa, ay maaaring makamit sa pamamagitan ng pag-refactor nito at paglalapat nito sa isang linya lamang.
Mga Pro Tips na Isaalang-alang Habang 'Refactoring'
Ang sumusunod ay ilang epektibong tip na dapat isaalang-alang habang “ refactoring ” ang mga pag-andar ng code:
- Kung may pangangailangan na magdagdag ng komento kapag nagsusulat ng isang paraan, ilagay ang functionality sa isang hiwalay na paraan.
- Sa kaso ng isang paraan na binubuo ng higit sa ' labinlima ” mga linya ng code, suriin ang mga gawain at subtask na ipinapatupad nito at subukang ilapat ang mga subtasks sa isang hiwalay na paraan.
- Alisin ang isang kumplikadong pamamaraan sa pamamagitan ng pagdaragdag ng bahagi ng paggana ng pamamaraan sa isang hiwalay na paraan.
- Ang mahabang listahan ng ' mga parameter ” ay mahirap maunawaan, at nakakalito ang paggamit ng mga pamamaraan na may ganitong mga parameter. Samakatuwid, mas mainam na ipasa ang isang buong bagay sa halip.
Mga Benepisyo ng 'Refactoring'
“ Refactoring ” ay nagbibigay ng mga sumusunod na benepisyo:
- Nag-aalok ito ng kaginhawahan sa paghahanap ng mga bug ng code.
- Pinapabuti ng refactoring ang kalidad ng code.
- Pina-streamline nito ang mga pag-andar ng code.
- Ang diskarte na ito ay nagpapabilis sa bilis ng pagbuo ng software.
- Nakakatulong ito sa pag-unawa at pagsusuri sa code na isinulat ng ibang mga developer.
Konklusyon
“ Refactoring ” sa Java ay tumutugma sa pagbabago at pagpapahusay ng istraktura ng code nang hindi binabago/binabago ang pag-andar nito, sa gayon ay na-streamline ang code. Ito ay isang matalinong diskarte na nakakatulong sa pamamahala ng memorya, pag-streamline ng code, at paghahanap ng mga limitasyon ng code nang maginhawa. Tinalakay ng artikulong ito ang pagtatrabaho ng refactoring sa Java.