త్రో చేయగల, బహుళ మినహాయింపులు, ఖరారు పద్ధతి లోపల మినహాయింపులు

"ఆహ్. నువ్వు ఉన్నావు. నీ కోసం వెతుకుతున్నాను."

"ఏమైనా జరిగిందా?"

"లేదు, కానీ మేము ఇంకా చదువుతున్నాము."

"సరే. నేను వింటున్నాను."

"నేను మీకు మినహాయింపుల గురించి మరికొన్ని విషయాలు చెప్పాలనుకుంటున్నాను:"

"జావా 7లో, బహుళ క్యాచ్ బ్లాక్‌ల జోడింపు ద్వారా ట్రై-క్యాచ్ నిర్మాణం కొద్దిగా విస్తరించబడింది . ఈ ఉదాహరణను చూడండి:"

try
{
  …
}
 catch (IOException ex)
{
 logger.log(ex);
 throw ex;
}
 catch (SQLException ex)
{
 logger.log(ex);
 throw ex;
}

try
{
  …
}
 catch (IOException | SQLException ex)
{
 logger.log(ex);
 throw ex;
}

"కాబట్టి ఇప్పుడు మనం OR ఆపరేటర్లచే వేరు చేయబడిన బహుళ మినహాయింపులను వ్రాయవచ్చా ('|' బైనరీ OR)?"

"అది సరే. సౌకర్యంగా లేదా?"

"హ్మ్. అయితే క్యాచ్ బ్లాక్ లోపల మినహాయింపు వస్తువు రకం ఏమిటి?"

"అన్ని తరువాత, IOException దాని పద్ధతులను కలిగి ఉంటుంది మరియు SQLException దాని పద్ధతులను కలిగి ఉంటుంది."

"మినహాయింపు రకం వారి సాధారణ పూర్వీకుల తరగతికి చెందినది."

"ఆహ్. మరో మాటలో చెప్పాలంటే, ఇది చాలా మటుకు మినహాయింపు లేదా రన్‌టైమ్ మినహాయింపు కావచ్చు . అలాంటప్పుడు క్యాచ్ (మినహాయింపు ఇ) అని ఎందుకు వ్రాయకూడదు?"

"కొన్నిసార్లు లోపాలను వ్యక్తిగతంగా నిర్వహించేటప్పుడు, వాటిని సమూహపరచడం, కొన్ని లోపాలను లాగ్‌లో వ్రాయడం, మరికొన్నింటిని తిరిగి విసరడం మరియు ఇతరులను వేరే విధంగా నిర్వహించడం సౌకర్యంగా ఉంటుంది."

"మరో మాటలో చెప్పాలంటే, ఈ పథకం విభిన్న లోపాలను నిర్వహించడానికి నకిలీ క్యాచ్ బ్లాక్‌ల సమస్యను పరిష్కరిస్తున్నట్లు గుర్తించబడింది."

"ఆహ్. నాకు అర్థమైంది. ధన్యవాదాలు, ఎల్లీ."

"అంతే కాదు. ఆఖరికి బ్లాక్ గురించి కొంచెం ఎక్కువ చెప్పాలనుకుంటున్నాను ."

"మీకు ఇప్పటికే తెలిసినట్లుగా, ఈ బ్లాక్ ఎల్లప్పుడూ అమలు చేయబడుతుంది."

"మరియు నేను ఎల్లప్పుడూ చెప్పినప్పుడు, నా ఉద్దేశ్యం ఖచ్చితంగా ఎల్లప్పుడూ ."

"ఉదాహరణకి:"

try
{
 return 1;
}
 finally
{
 return 0;
}

"ఇక్కడ ట్రై బ్లాక్‌లో రిటర్న్ ఉంది మరియు చివరగా బ్లాక్‌లో రిటర్న్ ఉంది . కాబట్టి ఈ పద్ధతి యొక్క రిటర్న్ విలువ సంఖ్య 0 అవుతుంది. "

" చివరిగా బ్లాక్ ఏమి జరిగినా అమలు చేస్తుంది. మరియు దాని రిటర్న్ స్టేట్‌మెంట్ ఇతర రిటర్న్ విలువను దాని స్వంత విలువతో ఓవర్‌రైట్ చేస్తుంది."

"అలాగా."

"అయితే, ఒక పద్ధతి విలువను తిరిగి ఇవ్వవచ్చు లేదా మినహాయింపును ఇవ్వవచ్చు. "

"కాబట్టి, ట్రై బ్లాక్‌లో విలువ తిరిగి ఇవ్వబడితే, చివరకు బ్లాక్ మినహాయింపును విసిరితే , ఫలితం మినహాయింపుగా ఉంటుంది . "

" ట్రై బ్లాక్‌లో మినహాయింపు విసిరినా చివరకు బ్లాక్ రిటర్న్ స్టేట్‌మెంట్‌ను కలిగి ఉంటే ఏమి చేయాలి?"

"అప్పుడు పద్ధతి సరిగ్గా పనిచేసినట్లు మరియు రిటర్న్ స్టేట్‌మెంట్‌లోని విలువ తిరిగి వచ్చినట్లు అవుతుంది.

try
{
 return 1;
}
 finally
{
 return 0;
}

try
{
 return 1;
}
 finally
{
 throw new RuntimeException();
}

try
{
 throw new RuntimeException();
}
 finally
{
 return 0;
}

try
{
 throw new RuntimeException();
}
 finally
{
 throw new IOException();
}

"చివరకు పద్ధతి అమలు చేయబడకపోవడానికి ఏకైక కారణం System.exit (); పద్ధతికి కాల్ చేయడం ద్వారా ప్రోగ్రామ్ యొక్క తక్షణ ముగింపు."

try
{
 System.exit(0);
 return 1;
}
 finally
{
 return 0;
}

"అలాగా."

"ఈ అంశాలన్నీ సాధారణంగా ఇంటర్వ్యూలలో అడుగుతాయని గుర్తుంచుకోండి, కాబట్టి మీరు వాటిని అర్థం చేసుకుని గుర్తుంచుకోవడం మంచిది."