మీ స్వంత మినహాయింపులను సృష్టించడం

మీరు బహుశా కోడ్‌ని అమలు చేసి, NullPointerException , ClassCastException , లేదా అధ్వాన్నమైన వాటితో ముగించే పరిస్థితిని మీరు బహుశా అనుభవించారని నేను భావిస్తున్నాను ... దీని తర్వాత డీబగ్గింగ్, విశ్లేషించడం, గూగ్లింగ్ మొదలైన సుదీర్ఘ ప్రక్రియ జరుగుతుంది. మినహాయింపులు అద్భుతంగా ఉన్నాయి: అవి సమస్య యొక్క స్వభావాన్ని మరియు అది ఎక్కడ సంభవించిందో సూచిస్తాయి. మీరు మీ జ్ఞాపకశక్తిని రిఫ్రెష్ చేసి మరికొంత నేర్చుకోవాలనుకుంటే, ఈ కథనాన్ని పరిశీలించండి: మినహాయింపులు: తనిఖీ చేయబడింది, తనిఖీ చేయబడలేదు మరియు అనుకూలం .

మీరు మీ స్వంత మినహాయింపును సృష్టించాల్సిన అవసరం వచ్చినప్పుడు పరిస్థితులు ఉండవచ్చు. ఉదాహరణకు, మీ కోడ్ కొన్ని కారణాల వల్ల అందుబాటులో లేని రిమోట్ సేవ నుండి సమాచారాన్ని అభ్యర్థించాలని అనుకుందాం. లేదా ఎవరైనా బ్యాంక్ కార్డ్ కోసం దరఖాస్తును పూరించి, ప్రమాదవశాత్తు లేదా కాకపోయినా, సిస్టమ్‌లోని మరొక వినియోగదారుతో ఇప్పటికే అనుబంధించబడిన ఫోన్ నంబర్‌ను అందించారని అనుకుందాం.

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

మినహాయింపును సృష్టిద్దాం:

public class PhoneNumberAlreadyExistsException extends Exception {

   public PhoneNumberAlreadyExistsException(String message) {
       super(message);
   }
}
    

తదుపరి మేము మా తనిఖీని నిర్వహించినప్పుడు దాన్ని ఉపయోగిస్తాము:

public class PhoneNumberRegisterService {
   List<String> registeredPhoneNumbers = Arrays.asList("+1-111-111-11-11", "+1-111-111-11-12", "+1-111-111-11-13", "+1-111-111-11-14");

   public void validatePhone(String phoneNumber) throws PhoneNumberAlreadyExistsException {
       if (registeredPhoneNumbers.contains(phoneNumber)) {
           throw new PhoneNumberAlreadyExistsException("The specified phone number is already in use by another customer!");
       }
   }
}
    

మా ఉదాహరణను సరళీకృతం చేయడానికి, మేము డేటాబేస్‌ను సూచించడానికి అనేక హార్డ్‌కోడ్ ఫోన్ నంబర్‌లను ఉపయోగిస్తాము. చివరగా, మా మినహాయింపును ఉపయోగించడానికి ప్రయత్నిద్దాం:

public class CreditCardIssue {
   public static void main(String[] args) {
       PhoneNumberRegisterService service = new PhoneNumberRegisterService();
       try {
           service.validatePhone("+1-111-111-11-14");
       } catch (PhoneNumberAlreadyExistsException e) {
           // Here we can write to logs or display the call stack
		e.printStackTrace();
       }
   }
}
    

ఇప్పుడు Shift+F10 (మీరు IDEAని ఉపయోగిస్తుంటే) నొక్కండి , అంటే ప్రాజెక్ట్‌ను అమలు చేయండి. ఇది మీరు కన్సోల్‌లో చూస్తారు:

నిన్ను చుసుకొ! మీరు మీ స్వంత మినహాయింపును సృష్టించారు మరియు దానిని కొంచెం పరీక్షించారు. ఈ విజయానికి అభినందనలు! కోడ్ ఎలా పనిచేస్తుందో బాగా అర్థం చేసుకోవడానికి దానితో కొంచెం ప్రయోగాలు చేయాలని నేను సిఫార్సు చేస్తున్నాను.

మరొక తనిఖీని జోడించండి - ఉదాహరణకు, ఫోన్ నంబర్‌లో అక్షరాలు ఉన్నాయో లేదో తనిఖీ చేయండి. మీకు తెలిసినట్లుగా, ఫోన్ నంబర్‌లను సులభంగా గుర్తుంచుకోవడానికి యునైటెడ్ స్టేట్స్‌లో అక్షరాలు తరచుగా ఉపయోగించబడతాయి, ఉదా 1-800-MY-APPLE. మీ చెక్ ఫోన్ నంబర్‌లో నంబర్‌లు మాత్రమే ఉన్నాయని నిర్ధారించుకోవచ్చు.

సరే, కాబట్టి మేము తనిఖీ చేయబడిన మినహాయింపును సృష్టించాము. అంతా బాగానే ఉంటుంది, కానీ...

ప్రోగ్రామింగ్ సంఘం రెండు శిబిరాలుగా విభజించబడింది - తనిఖీ చేయబడిన మినహాయింపులకు అనుకూలంగా ఉన్నవారు మరియు వాటిని వ్యతిరేకించే వారు. ఇరుపక్షాలు బలమైన వాదనలు వినిపిస్తున్నాయి. ఇద్దరిలో అగ్రశ్రేణి డెవలపర్‌లు ఉన్నారు: బ్రూస్ ఎకెల్ తనిఖీ చేసిన మినహాయింపులను విమర్శించాడు, జేమ్స్ గోస్లింగ్ వాటిని సమర్థించాడు. ఈ విషయం ఎప్పటికీ శాశ్వతంగా పరిష్కరించబడదు. తనిఖీ చేయబడిన మినహాయింపులను ఉపయోగించడం యొక్క ప్రధాన ప్రతికూలతలను చూద్దాం.

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

అలాగే, మేము "బాయిలర్‌ప్లేట్" కోడ్‌తో ముగించవచ్చు, అంటే చాలా స్థలాన్ని ఆక్రమించే కోడ్, కానీ ఎక్కువ బరువులు ఎత్తడం లేదు.

చాలా పెద్ద అప్లికేషన్‌లలో చాలా మినహాయింపులు నిర్వహించబడుతున్నాయి: టాప్-లెవల్ పద్ధతిలో త్రోల జాబితా డజను మినహాయింపులను చేర్చడానికి సులభంగా పెరుగుతుంది.

డెవలపర్‌లు సాధారణంగా దీన్ని ఇష్టపడరు మరియు బదులుగా ఒక ట్రిక్‌ని ఎంచుకుంటారు: వారు వారి తనిఖీ చేసిన మినహాయింపులన్నింటినీ ఒక సాధారణ పూర్వీకునిగా వారసత్వంగా పొందేలా చేస్తారు — ApplicationNameException . ఇప్పుడు వారు హ్యాండ్లర్‌లో ఆ ( తనిఖీ చేయబడింది !) మినహాయింపును కూడా పట్టుకోవాలి :

catch (FirstException e) {
    // TODO
}
catch (SecondException e) {
    // TODO
}
catch (ThirdException e) {
    // TODO
}
catch (ApplicationNameException e) {
    // TODO
}
    

ఇక్కడ మనం మరొక సమస్యను ఎదుర్కొంటాము — చివరి క్యాచ్ బ్లాక్‌లో మనం ఏమి చేయాలి ? పైన, మేము ఇప్పటికే ఊహించిన అన్ని పరిస్థితులను ప్రాసెస్ చేసాము, కాబట్టి ఈ సమయంలో ApplicationNameException అంటే " మినహాయింపు : కొన్ని అపారమయిన లోపం సంభవించింది" తప్ప మరేమీ కాదు. మేము దీన్ని ఎలా నిర్వహిస్తాము:

catch (ApplicationNameException e) {
    LOGGER.error("Unknown error", e.getMessage());
}
    

మరియు చివరికి, ఏమి జరిగిందో మాకు తెలియదు.

అయితే ఇలా ప్రతి మినహాయింపును ఒకేసారి విసిరేయలేమా?

public void ourCoolMethod() throws Exception {
// Do some work
}
    

అవును, మనం చేయగలం. కానీ "త్రోస్ మినహాయింపు" మనకు ఏమి చెబుతుంది? ఏదో విరిగిపోయిందని. కారణాన్ని అర్థం చేసుకోవడానికి మీరు పై నుండి క్రిందికి అన్నింటినీ పరిశోధించవలసి ఉంటుంది మరియు డీబగ్గర్‌తో చాలా కాలం పాటు హాయిగా ఉండండి.

మీరు కొన్నిసార్లు "మినహాయింపు మింగడం" అని పిలువబడే నిర్మాణాన్ని కూడా ఎదుర్కోవచ్చు:

try {
// Some code
} catch(Exception e) {
   throw new ApplicationNameException("Error");
}
    

వివరణ ద్వారా ఇక్కడ జోడించడానికి ఎక్కువ ఏమీ లేదు - కోడ్ ప్రతిదీ స్పష్టంగా చేస్తుంది లేదా బదులుగా, ప్రతిదీ అస్పష్టంగా చేస్తుంది.

అయితే, మీరు దీన్ని నిజమైన కోడ్‌లో చూడలేరని మీరు చెప్పవచ్చు. సరే, java.net ప్యాకేజీ నుండి URL క్లాస్ యొక్క ప్రేగులను (కోడ్) పరిశీలిద్దాం . మీరు తెలుసుకోవాలనుకుంటే నన్ను అనుసరించండి!

URL తరగతిలోని నిర్మాణాలలో ఒకటి ఇక్కడ ఉంది :

public URL(String spec) throws MalformedURLException {
   this(null, spec);
}
    

మీరు చూడగలిగినట్లుగా, మాకు ఆసక్తికరమైన తనిఖీ చేయబడిన మినహాయింపు ఉంది - MalformedURLException . ఇది ఎప్పుడు విసిరివేయబడవచ్చు (మరియు నేను కోట్ చేస్తున్నాను):
"ప్రోటోకాల్ పేర్కొనబడకపోతే, లేదా తెలియని ప్రోటోకాల్ కనుగొనబడకపోతే, లేదా స్పెక్ శూన్యంగా ఉంటే లేదా అన్వయించబడిన URL అనుబంధిత ప్రోటోకాల్ యొక్క నిర్దిష్ట సింటాక్స్‌కు అనుగుణంగా విఫలమైతే."

అంటే:

1. ఏ ప్రోటోకాల్ పేర్కొనబడకపోతే.
2. తెలియని ప్రోటోకాల్ కనుగొనబడింది.
3. స్పెక్ శూన్యం .
4. URL అనుబంధిత ప్రోటోకాల్ యొక్క నిర్దిష్ట సింటాక్స్‌కు అనుగుణంగా లేదు.

URL ఆబ్జెక్ట్‌ని సృష్టించే పద్ధతిని క్రియేట్ చేద్దాం :

public URL createURL() {
   URL url = new URL("https://codegym.cc");
   return url;
}
    

మీరు IDEలో ఈ పంక్తులను వ్రాసిన వెంటనే (నేను IDEAలో కోడింగ్ చేస్తున్నాను, కానీ ఇది ఎక్లిప్స్ మరియు NetBeansలో కూడా పని చేస్తుంది), మీరు దీన్ని చూస్తారు:

దీనర్థం మనం మినహాయింపును వేయాలి లేదా ట్రై-క్యాచ్ బ్లాక్‌లో కోడ్‌ను చుట్టాలి. ప్రస్తుతానికి, ఏమి జరుగుతుందో ఊహించడానికి రెండవ ఎంపికను ఎంచుకోవాలని నేను సూచిస్తున్నాను:

public static URL createURL() {
   URL url = null;
   try {
       url = new URL("https://codegym.cc");
   } catch(MalformedURLException e) {
  e.printStackTrace();
   }
   return url;
}
    

మీరు చూడగలిగినట్లుగా, కోడ్ ఇప్పటికే వెర్బోస్‌గా ఉంది. మరియు మేము దానిని పైన సూచించాము. ఎంపిక చేయని మినహాయింపులను ఉపయోగించడానికి ఇది చాలా స్పష్టమైన కారణాలలో ఒకటి.

జావాలో RuntimeExceptionని పొడిగించడం ద్వారా మనం ఎంపిక చేయని మినహాయింపును సృష్టించవచ్చు .

తనిఖీ చేయని మినహాయింపులు ఎర్రర్ క్లాస్ లేదా రన్‌టైమ్ ఎక్సెప్షన్ క్లాస్ నుండి వారసత్వంగా పొందబడతాయి . చాలా మంది ప్రోగ్రామర్లు ఈ మినహాయింపులు మా ప్రోగ్రామ్‌లలో నిర్వహించబడతాయని భావిస్తారు ఎందుకంటే అవి ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు మేము తిరిగి పొందలేమని ఆశించలేని లోపాలను సూచిస్తాయి.

ఎంపిక చేయని మినహాయింపు సంభవించినప్పుడు, ఇది సాధారణంగా కోడ్‌ను తప్పుగా ఉపయోగించడం, శూన్యమైన లేదా చెల్లని వాదనలో పాస్ చేయడం వలన సంభవిస్తుంది.

సరే, కోడ్ వ్రాద్దాం:

public class OurCoolUncheckedException extends RuntimeException {
   public OurCoolUncheckedException(String message) {
       super(message);
   }

   public OurCoolUncheckedException(Throwable cause) {
       super(cause);
   }
  
   public OurCoolUncheckedException(String message, Throwable throwable) {
       super(message, throwable);
   }
}
    

మేము వివిధ ప్రయోజనాల కోసం బహుళ కన్స్ట్రక్టర్‌లను తయారు చేసాము. ఇది మా మినహాయింపుకు మరిన్ని సామర్థ్యాలను అందించడానికి అనుమతిస్తుంది. ఉదాహరణకు, మినహాయింపు మనకు ఎర్రర్ కోడ్‌ని ఇచ్చేలా మనం దీన్ని తయారు చేయవచ్చు. ప్రారంభించడానికి, మన ఎర్రర్ కోడ్‌లను సూచించడానికి ఒక enumని తయారు చేద్దాం:

public enum ErrorCodes {
   FIRST_ERROR(1),
   SECOND_ERROR(2),
   THIRD_ERROR(3);

   private int code;

   ErrorCodes(int code) {
       this.code = code;
   }

   public int getCode() {
       return code;
   }
}
    

ఇప్పుడు మన మినహాయింపు తరగతికి మరొక కన్స్ట్రక్టర్‌ని జోడిద్దాం:

public OurCoolUncheckedException(String message, Throwable cause, ErrorCodes errorCode) {
   super(message, cause);
   this.errorCode = errorCode.getCode();
}
    

మరియు ఫీల్డ్‌ను జోడించడం మర్చిపోవద్దు (మేము దాదాపు మర్చిపోయాము):

private Integer errorCode;
    

మరియు వాస్తవానికి, ఈ కోడ్‌ని పొందడానికి ఒక పద్ధతి:

public Integer getErrorCode() {
   return errorCode;
}
    

మొత్తం తరగతిని చూద్దాం, తద్వారా మేము దానిని తనిఖీ చేయవచ్చు మరియు సరిపోల్చవచ్చు:

public class OurCoolUncheckedException extends RuntimeException {
   private Integer errorCode;

   public OurCoolUncheckedException(String message) {
       super(message);
   }

   public OurCoolUncheckedException(Throwable cause) {
       super(cause);
   }

   public OurCoolUncheckedException(String message, Throwable throwable) {

       super(message, throwable);
   }

   public OurCoolUncheckedException(String message, Throwable cause, ErrorCodes errorCode) {
       super(message, cause);
       this.errorCode = errorCode.getCode();
   }
   public Integer getErrorCode() {
       return errorCode;
   }
}
    

టా-డా! మా మినహాయింపు పూర్తయింది! మీరు గమనిస్తే, ఇక్కడ ప్రత్యేకంగా సంక్లిష్టంగా ఏమీ లేదు. దీన్ని చర్యలో చూద్దాం:

   public static void main(String[] args) {
       getException();
   }
   public static void getException() {
       throw new OurCoolUncheckedException("Our cool exception!");
   }
    

మేము మా చిన్న అనువర్తనాన్ని అమలు చేసినప్పుడు, కన్సోల్‌లో క్రింది వాటిని చూస్తాము:

ఇప్పుడు మనం జోడించిన అదనపు కార్యాచరణ యొక్క ప్రయోజనాన్ని పొందండి. మేము మునుపటి కోడ్‌కు కొద్దిగా జోడిస్తాము:

public static void main(String[] args) throws Exception {

   OurCoolUncheckedException exception = getException(3);
   System.out.println("getException().getErrorCode() = " + exception.getErrorCode());
   throw exception;

}

public static OurCoolUncheckedException getException(int errorCode) {
   return switch (errorCode) {
   case 1:
       return new OurCoolUncheckedException("Our cool exception! An error occurred: " + ErrorCodes.FIRST_ERROR.getCode(), new Throwable(), ErrorCodes.FIRST_ERROR);
   case 2:
       return new OurCoolUncheckedException("Our cool exception! An error occurred: " + ErrorCodes.SECOND_ERROR.getCode(), new Throwable(), ErrorCodes.SECOND_ERROR);
   default: // Since this is the default action, here we catch the third and any other codes that we have not yet added. You can learn more by reading Java switch statement
       return new OurCoolUncheckedException("Our cool exception! An error occurred: " + ErrorCodes.THIRD_ERROR.getCode(), new Throwable(), ErrorCodes.THIRD_ERROR);
}

}
    

మీరు వస్తువులతో పని చేసే విధంగానే మీరు మినహాయింపులతో పని చేయవచ్చు. అయితే, జావాలోని ప్రతిదీ ఒక వస్తువు అని మీకు ఇప్పటికే తెలుసునని నేను ఖచ్చితంగా అనుకుంటున్నాను.

మరి మనం ఏం చేశామో చూడండి. మొదట, మేము పద్ధతిని మార్చాము, ఇది ఇప్పుడు త్రో చేయదు, కానీ బదులుగా కేవలం ఇన్‌పుట్ పరామితిని బట్టి మినహాయింపును సృష్టిస్తుంది. తరువాత, స్విచ్-కేస్ స్టేట్‌మెంట్ ఉపయోగించి, మేము కోరుకున్న ఎర్రర్ కోడ్ మరియు సందేశంతో మినహాయింపును రూపొందిస్తాము. మరియు ప్రధాన పద్ధతిలో, మేము సృష్టించిన మినహాయింపును పొందుతాము, లోపం కోడ్ను పొందండి మరియు దానిని విసిరాము.

దీన్ని అమలు చేసి, కన్సోల్‌లో మనకు ఏమి లభిస్తుందో చూద్దాం:

చూడండి - మేము మినహాయింపు నుండి పొందిన దోష కోడ్‌ను ముద్రించాము మరియు మినహాయింపును విసిరాము. అంతేకాదు, మినహాయింపు ఎక్కడ వేయబడిందో కూడా మనం ట్రాక్ చేయవచ్చు. అవసరమైతే, మీరు సందేశానికి సంబంధించిన మొత్తం సమాచారాన్ని జోడించవచ్చు, అదనపు ఎర్రర్ కోడ్‌లను సృష్టించవచ్చు మరియు మీ మినహాయింపులకు కొత్త లక్షణాలను జోడించవచ్చు.

సరే, దాని గురించి మీరు ఏమనుకుంటున్నారు? ప్రతిదీ మీ కోసం పని చేస్తుందని నేను ఆశిస్తున్నాను!

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

బ్రూస్ ఎకెల్ తన "థింకింగ్ ఇన్ జావా" పుస్తకంలోని 12వ అధ్యాయంలో మినహాయింపుల గురించి చాలా బాగా రాశాడు — మీరు దీన్ని చదవమని నేను సిఫార్సు చేస్తున్నాను! హార్స్ట్‌మన్ యొక్క "కోర్ జావా" యొక్క మొదటి సంపుటాన్ని కూడా పరిశీలించండి — ఇందులో 7వ అధ్యాయంలో చాలా ఆసక్తికరమైన అంశాలు కూడా ఉన్నాయి.

ఒక చిన్న సారాంశం

1. ప్రతిదీ ఒక లాగ్‌లో వ్రాయండి! విసిరిన మినహాయింపులలో సందేశాలను లాగ్ చేయండి. ఇది సాధారణంగా డీబగ్గింగ్‌లో చాలా సహాయపడుతుంది మరియు ఏమి జరిగిందో అర్థం చేసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. క్యాచ్ బ్లాక్‌ను ఖాళీగా ఉంచవద్దు , లేకుంటే అది మినహాయింపును "మింగుతుంది" మరియు సమస్యలను వేటాడేందుకు మీకు ఎలాంటి సమాచారం ఉండదు.

2. మినహాయింపుల విషయానికి వస్తే, వారందరినీ ఒకేసారి పట్టుకోవడం చెడ్డ పద్ధతి (నా సహోద్యోగి చెప్పినట్లుగా, "ఇది పోకీమాన్ కాదు, ఇది జావా"), కాబట్టి క్యాచ్‌ను నివారించండి (మినహాయింపు ఇ) లేదా అధ్వాన్నంగా, క్యాచ్ ( త్రోబుల్ t ) ​​.

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

4. కోడ్‌లోని ఇతర భాగాలకు కాల్ చేస్తున్నప్పుడు, కొన్ని మినహాయింపులను పొందడం ఉత్తమం. పిలవబడే కోడ్ బహుళ మినహాయింపులను విసిరినట్లయితే, ఆ మినహాయింపుల యొక్క పేరెంట్ క్లాస్‌ను మాత్రమే పట్టుకోవడం పేలవమైన ప్రోగ్రామింగ్ అభ్యాసం. ఉదాహరణకు, మీరు FileNotFoundException మరియు IOExceptionని విసిరే కోడ్‌ని కాల్ చేయండి . ఈ మాడ్యూల్‌ని పిలిచే మీ కోడ్‌లో, మినహాయింపులను క్యాచ్ చేయడానికి ఒక్క క్యాచ్‌కు బదులుగా, ప్రతి మినహాయింపులను క్యాచ్ చేయడానికి రెండు క్యాచ్ బ్లాక్‌లను వ్రాయడం మంచిది .

5. మీరు వినియోగదారుల కోసం మరియు డీబగ్గింగ్ కోసం వాటిని సమర్థవంతంగా నిర్వహించగలిగినప్పుడు మాత్రమే మినహాయింపులను క్యాచ్ చేయండి.

6. మీ స్వంత మినహాయింపులను వ్రాయడానికి సంకోచించకండి. వాస్తవానికి, జావాలో చాలా రెడీమేడ్ వాటిని కలిగి ఉంది, ప్రతి సందర్భానికి ఏదో ఒకటి, కానీ కొన్నిసార్లు మీరు ఇప్పటికీ మీ స్వంత "చక్రం" కనిపెట్టాలి. కానీ మీరు దీన్ని ఎందుకు చేస్తున్నారో మీరు స్పష్టంగా అర్థం చేసుకోవాలి మరియు ప్రామాణికమైన మినహాయింపుల సెట్‌లో మీకు అవసరమైనవి ఇప్పటికే లేవని నిర్ధారించుకోండి.

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

8. మీ మినహాయింపులను డాక్యుమెంట్ చేయండి. మినహాయింపుల కోసం @throws Javadoc ట్యాగ్‌ని వ్రాయమని మేము సిఫార్సు చేస్తున్నాము. మీ కోడ్ ఏదైనా ఇంటర్‌ఫేస్‌లను అందించినప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. మరియు మీరు తర్వాత మీ స్వంత కోడ్‌ను అర్థం చేసుకోవడం కూడా సులభం అవుతుంది. మీరు ఏమి అనుకుంటున్నారు, MalformedURLexception దేనికి సంబంధించినదో మీరు ఎలా గుర్తించగలరు ? జావాడోక్ నుండి! అవును, డాక్యుమెంటేషన్ రాయాలనే ఆలోచన చాలా ఆకర్షణీయంగా లేదు, కానీ నన్ను నమ్మండి, మీరు ఆరు నెలల తర్వాత మీ స్వంత కోడ్‌కి తిరిగి వచ్చినప్పుడు మీరే కృతజ్ఞతలు తెలుపుతారు.

9. వనరులను విడుదల చేయండి మరియు వనరులతో ప్రయత్నించండి నిర్మాణాన్ని నిర్లక్ష్యం చేయవద్దు .

10. ఇక్కడ మొత్తం సారాంశం ఉంది: మినహాయింపులను తెలివిగా ఉపయోగించండి. మినహాయింపును విసరడం అనేది వనరుల పరంగా చాలా "ఖరీదైన" చర్య. అనేక సందర్భాల్లో, మినహాయింపులను విసిరివేయడాన్ని నివారించడం సులభం కావచ్చు మరియు బదులుగా ఒక బూలియన్ వేరియబుల్‌ను తిరిగి ఇవ్వడం సులభం కావచ్చు, ఆపరేషన్ విజయవంతమైందో లేదో, సాధారణ మరియు "తక్కువ ఖరీదైనది" if-else .

    ఇది మీరు స్పష్టంగా చేయకూడని మినహాయింపులతో అప్లికేషన్ లాజిక్‌ను ముడిపెట్టడం కూడా ఉత్సాహం కలిగిస్తుంది. మేము వ్యాసం ప్రారంభంలో చెప్పినట్లుగా, అసాధారణమైన పరిస్థితులకు మినహాయింపులు, ఊహించినవి కావు మరియు వాటిని నిరోధించడానికి వివిధ సాధనాలు ఉన్నాయి. ప్రత్యేకించి, IOException ను నిరోధించడానికి NullPointerException లేదా Scanner.hasNext మరియు వంటి వాటిని నిరోధించడానికి ఐచ్ఛికం ఉంది , ఇది రీడ్() పద్ధతి విసిరివేయవచ్చు.