Ang sagot ay ang mga hindi nababagong uri ay mas ligtas mula sa mga bug, mas madaling maunawaan, at mas handa para sa pagbabago. Dahil sa pagbabago pinahihirapang maunawaan kung ano ang ginagawa ng iyong programa, at mas mahirap ipatupad ang mga kontrata.
Masama ba ang mga nababagong bagay?
Sa wakas, ang mga nababagong bagay ay pamatay sa magkasabay na sitwasyon. Sa tuwing maa-access mo ang isang nababagong bagay mula sa magkakahiwalay na mga thread, kailangan mong harapin ang pag-lock. Binabawasan nito ang throughput at ginagawang mas mahirap pangalagaan ang iyong code.
Bakit masama ang shared state?
Ang nakabahaging mutable na estado ay gumagana tulad ng sumusunod: Kung ang dalawa o higit pang partido ay maaaring baguhin ang parehong data (mga variable, bagay, atbp.). At kung magkakapatong ang kanilang mga buhay. Pagkatapos ay may panganib ng mga pagbabago ng isang partido na pumipigil sa ibang mga partido na gumana nang tama.
Bakit isang magandang bagay ang immutability?
Bukod sa pinababang paggamit ng memory, ang immutability ay nagbibigay-daan sa iyong i-optimize ang iyong application sa pamamagitan ng paggamit ng reference- at pagkakapantay-pantay ng halaga. Ginagawa nitong talagang madaling makita kung may nagbago. Halimbawa, pagbabago ng estado sa isang bahagi ng reaksyon.
Ano ang mga disadvantage ng immutability?
Ang tanging tunay na disbentaha ng mga hindi nababagong klase ay na nangangailangan sila ng hiwalay na object para sa bawat natatanging value. Maaaring magastos ang paggawa ng mga bagay na ito, lalo na kung malaki ang mga ito. Halimbawa, ipagpalagay na mayroon kang isang million-bit na BigInteger at gusto mong baguhin ang low-order bit nito:BigInteger moby=…; moby=moby.
