మినహాయింపును చుట్టడం

3. మినహాయింపులు చుట్టడం

తనిఖీ చేయబడిన మినహాయింపులు సిద్ధాంతంలో చల్లగా అనిపించాయి, కానీ ఆచరణలో చాలా నిరాశగా మారాయి.

మీరు మీ ప్రాజెక్ట్‌లో సూపర్ పాపులర్ పద్ధతిని కలిగి ఉన్నారని అనుకుందాం. ఇది మీ ప్రోగ్రామ్‌లోని వందలాది ప్రదేశాల నుండి పిలువబడుతుంది. మరియు మీరు దీనికి కొత్త తనిఖీ చేయబడిన మినహాయింపును జోడించాలని నిర్ణయించుకుంటారు . మరియు ఈ తనిఖీ చేయబడిన మినహాయింపు నిజంగా ముఖ్యమైనది మరియు చాలా ప్రత్యేకమైనది కావచ్చు , main()అది పట్టుబడితే ఏమి చేయాలో మాత్రమే పద్ధతికి తెలుసు.

అంటే మీరు మీ సూపర్ పాపులర్ మెథడ్‌ని పిలిచే ప్రతి పద్ధతి యొక్క నిబంధనకు తనిఖీ చేయబడిన మినహాయింపును జోడించాలిthrows . అలాగే throwsఆ పద్ధతులను పిలిచే అన్ని పద్ధతుల యొక్క నిబంధనలో. మరియు ఆ పద్ధతులను పిలిచే పద్ధతులు.

ఫలితంగా, throwsప్రాజెక్ట్‌లోని సగం పద్ధతుల యొక్క నిబంధనలు కొత్త తనిఖీ చేయబడిన మినహాయింపును పొందుతాయి. మరియు వాస్తవానికి మీ ప్రాజెక్ట్ పరీక్షల ద్వారా కవర్ చేయబడింది మరియు ఇప్పుడు పరీక్షలు కంపైల్ చేయవు. మరియు ఇప్పుడు మీరు మీ పరీక్షలలోని త్రోస్ క్లాజులను కూడా సవరించాలి.

ఆపై మీ అన్ని కోడ్‌లు (వందలాది ఫైల్‌లలోని అన్ని మార్పులు) ఇతర ప్రోగ్రామర్లచే సమీక్షించబడాలి. మరియు ఈ సమయంలో మేము ప్రాజెక్ట్‌లో చాలా రక్తపాత మార్పులు ఎందుకు చేసాము అని మనల్ని మనం ప్రశ్నించుకుంటాము? రోజు(లు?) పని, మరియు విరిగిన పరీక్షలు — అన్నీ ఒక తనిఖీ చేయబడిన మినహాయింపును జోడించడం కోసమేనా ?

మరియు వాస్తవానికి, వారసత్వం మరియు పద్ధతిని అధిగమించడానికి సంబంధించిన సమస్యలు ఇప్పటికీ ఉన్నాయి. తనిఖీ చేయబడిన మినహాయింపుల నుండి వచ్చే సమస్యలు ప్రయోజనం కంటే చాలా పెద్దవి. బాటమ్ లైన్ ఏమిటంటే, ఇప్పుడు కొంతమంది వాటిని ఇష్టపడతారు మరియు కొంతమంది వాటిని ఉపయోగిస్తున్నారు.

అయినప్పటికీ, ఈ తనిఖీ చేయబడిన మినహాయింపులను కలిగి ఉన్న చాలా కోడ్ (ప్రామాణిక జావా లైబ్రరీ కోడ్‌తో సహా) ఇప్పటికీ ఉంది . వారితో ఏమి చేయాలి? మేము వాటిని విస్మరించలేము మరియు వాటిని ఎలా నిర్వహించాలో మాకు తెలియదు.

జావా ప్రోగ్రామర్లు తనిఖీ చేయబడిన మినహాయింపులను వ్రాప్ చేయాలని ప్రతిపాదించారు RuntimeException. మరో మాటలో చెప్పాలంటే, తనిఖీ చేయబడిన అన్ని మినహాయింపులను పట్టుకుని , ఆపై ఎంపిక చేయని మినహాయింపులను సృష్టించండి (ఉదాహరణకు, RuntimeException) మరియు బదులుగా వాటిని విసిరేయండి. అలా చేయడం ఇలా కనిపిస్తుంది:

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

ఇది చాలా అందమైన పరిష్కారం కాదు, కానీ ఇక్కడ నేరపూరితంగా ఏమీ లేదు: మినహాయింపు ఒక లోపల నింపబడింది RuntimeException.

కావాలనుకుంటే, మీరు దానిని అక్కడ నుండి సులభంగా తిరిగి పొందవచ్చు. ఉదాహరణ:

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
   }
}