Pagbabalot ng isang pagbubukod

3. Pagbubukod sa pagbabalot

Ang mga nasuri na eksepsiyon ay tila cool sa teorya, ngunit naging isang malaking pagkabigo sa pagsasanay.

Ipagpalagay na mayroon kang isang napakapopular na pamamaraan sa iyong proyekto. Tinatawag ito mula sa daan-daang lugar sa iyong programa. At nagpasya kang magdagdag ng bagong may check na exception dito. At maaaring ang naka-check na exception na ito ay talagang mahalaga at napakaespesyal na ang main()paraan lamang ang nakakaalam kung ano ang gagawin kung ito ay nahuli.

Nangangahulugan iyon na kailangan mong idagdag ang naka-check na exception sa throwssugnay ng bawat paraan na tumatawag sa iyong napakasikat na paraan . Pati na rin sa throwssugnay ng lahat ng mga pamamaraan na tumatawag sa mga pamamaraang iyon. At sa mga pamamaraan na tumatawag sa mga pamamaraang iyon.

Bilang resulta, ang throwsmga sugnay ng kalahati ng mga pamamaraan sa proyekto ay nakakakuha ng bagong naka-check na exception. At siyempre ang iyong proyekto ay sakop ng mga pagsubok, at ngayon ang mga pagsubok ay hindi nag-compile. At ngayon kailangan mo ring i-edit ang mga throws clause sa iyong mga pagsubok.

At pagkatapos ang lahat ng iyong code (lahat ng mga pagbabago sa daan-daang mga file) ay kailangang suriin ng iba pang mga programmer. At sa puntong ito tinatanong natin ang ating sarili kung bakit gumawa tayo ng napakaraming madugong pagbabago sa proyekto? (mga?) araw ng trabaho, at mga sirang pagsubok — lahat para sa kapakanan ng pagdaragdag ng isang may check na exception?

At siyempre, may mga problema pa rin na may kaugnayan sa mana at overriding ng pamamaraan. Ang mga problemang nagmumula sa mga nasuri na eksepsiyon ay mas malaki kaysa sa benepisyo. Ang bottomline ay ngayon ay kakaunti na ang nagmamahal sa kanila at kakaunti ang gumagamit nito.

Gayunpaman, mayroon pa ring maraming code (kabilang ang karaniwang Java library code) na naglalaman ng mga naka-check na exception na ito. Ano ang dapat gawin sa kanila? Hindi namin sila maaaring balewalain, at hindi namin alam kung paano haharapin ang mga ito.

Iminungkahi ng mga programmer ng Java na i-wrap ang mga naka-check na exception sa RuntimeException. Sa madaling salita, hulihin ang lahat ng may check na mga exception at pagkatapos ay lumikha ng mga hindi naka-check na mga exception (halimbawa, RuntimeException) at itapon ang mga ito sa halip. Ang paggawa nito ay mukhang ganito:

try
{
   // Code where a checked exception might occur
}
catch(Exception exp)
{
   throw new RuntimeException(exp);
}

Ito ay hindi isang napakagandang solusyon, ngunit walang kriminal dito: ang pagbubukod ay pinalamanan lamang sa loob ng isang RuntimeException.

Kung ninanais, madali mong makuha ito mula doon. Halimbawa:

try
{
   // Code where we wrap the checked exception
   // in a RuntimeException
}
catch(RuntimeException e)
{
   Throwable cause = e.getCause();
   if (cause instanceof Exception)
   {
      Exception exp = (Exception) cause;
      // Exception handling code goes here
   }
}