హాయ్! నేను దానిని ప్రస్తావించడం అసహ్యించుకుంటాను, కానీ ప్రోగ్రామర్ యొక్క పనిలో ఎక్కువ భాగం లోపాలతో వ్యవహరిస్తోంది. చాలా తరచుగా, అతని లేదా ఆమె స్వంతం. తప్పు చేయని వారు లేరని తేలింది. మరియు అలాంటి కార్యక్రమాలు కూడా లేవు. మినహాయింపులు: పట్టుకోవడం మరియు నిర్వహించడం - 1 వాస్తవానికి, లోపంతో వ్యవహరించేటప్పుడు, ప్రధాన విషయం దాని కారణాన్ని అర్థం చేసుకోవడం. మరియు చాలా విషయాలు ప్రోగ్రామ్‌లో బగ్‌లను కలిగిస్తాయి. ఏదో ఒక సమయంలో, జావా సృష్టికర్తలు ఎక్కువగా ప్రోగ్రామింగ్ లోపాలతో ఏమి చేయాలి అని తమను తాము ప్రశ్నించుకున్నారు? వాటిని పూర్తిగా నివారించడం వాస్తవికమైనది కాదు, ప్రోగ్రామర్లు మీరు ఊహించలేని అంశాలను వ్రాయగలరు. :) కాబట్టి, లోపాలతో పనిచేయడానికి మనం భాషకు మెకానిజం ఇవ్వాలి. మరో మాటలో చెప్పాలంటే, మీ ప్రోగ్రామ్‌లో లోపం ఉన్నట్లయితే, తదుపరి ఏమి చేయాలనే దాని కోసం మీకు ఒక విధమైన స్క్రిప్ట్ అవసరం. లోపం సంభవించినప్పుడు ప్రోగ్రామ్ సరిగ్గా ఏమి చేయాలి? ఈ రోజు మనం ఈ మెకానిజంతో పరిచయం పొందుతాము. దీనిని " జావాలో మినహాయింపులు " అంటారు.

మినహాయింపు ఏమిటి?

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

public class Main {

   public static void main(String[] args) throws IOException {
       BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));
       String firstString = reader.readLine();
       System.out.println(firstString);
   }
}
కానీ అలాంటి ఫైల్ లేకపోతే ఎలా! ప్రోగ్రామ్ మినహాయింపును రూపొందిస్తుంది: FileNotFoundException. అవుట్‌పుట్: థ్రెడ్ "ప్రధాన" java.io.FileNotFoundException: C:\Users\Username\Desktop\test.txt (సిస్టమ్ పేర్కొన్న మార్గాన్ని కనుగొనలేదు) జావాలో, ప్రతి మినహాయింపు ప్రత్యేక తరగతి ద్వారా సూచించబడుతుంది. ఈ మినహాయింపు తరగతులన్నీ సాధారణ "పూర్వీకులు"-మాతృ Throwableతరగతి నుండి ఉద్భవించాయి. మినహాయింపు తరగతి పేరు సాధారణంగా మినహాయింపు ఎందుకు సంభవించిందో సంక్షిప్తంగా ప్రతిబింబిస్తుంది:
  • FileNotFoundException(ఫైల్ కనుగొనబడలేదు)

  • ArithmeticException(గణిత ఆపరేషన్ చేస్తున్నప్పుడు మినహాయింపు సంభవించింది)

  • ArrayIndexOutOfBoundsException(సూచిక శ్రేణి యొక్క హద్దులు దాటి ఉంది). ఉదాహరణకు, మీరు కేవలం 10 ఎలిమెంట్‌లను కలిగి ఉన్న శ్రేణి యొక్క 23వ స్థానాన్ని ప్రదర్శించడానికి ప్రయత్నిస్తే ఈ మినహాయింపు ఏర్పడుతుంది.
మొత్తంగా, జావాలో దాదాపు 400 తరగతులు ఉన్నాయి! ఎందుకు చాలా? ప్రోగ్రామర్లు పని చేయడానికి వాటిని మరింత సౌకర్యవంతంగా చేయడానికి. దీన్ని ఊహించండి: మీరు ఒక ప్రోగ్రామ్‌ను వ్రాస్తారు మరియు అది నడుస్తున్నప్పుడు ఇది ఇలా కనిపించే మినహాయింపును సృష్టిస్తుంది: 

Exception in thread "main"
ఊహూ. :/ అది పెద్దగా సహాయం చేయదు. లోపం అంటే ఏమిటో లేదా అది ఎక్కడ నుండి వచ్చిందో స్పష్టంగా లేదు. ఇక్కడ ఉపయోగకరమైన సమాచారం లేదు. కానీ జావాలోని అనేక రకాల మినహాయింపు తరగతులు ప్రోగ్రామర్‌కు చాలా ముఖ్యమైన వాటిని అందిస్తాయి: లోపం రకం మరియు దాని సంభావ్య కారణం (తరగతి పేరులో పొందుపరచబడింది). ఇది చూడటానికి చాలా మరొక విషయం 

Exception in thread "main" java.io.FileNotFoundException: C:\Users\Username\Desktop\test.txt (The system cannot find the specified path)
సమస్య ఏమిటో మరియు సమస్యను పరిష్కరించడానికి ఎక్కడ త్రవ్వడం ప్రారంభించాలో వెంటనే స్పష్టమవుతుంది! మినహాయింపులు, ఏవైనా తరగతుల ఉదాహరణలు వంటివి వస్తువులు.

మినహాయింపులను పట్టుకోవడం మరియు నిర్వహించడం

జావా మినహాయింపులతో పని చేయడానికి ప్రత్యేక కోడ్ బ్లాక్‌లను కలిగి ఉంది: try, catchమరియు finally. మినహాయింపులు: పట్టుకోవడం మరియు నిర్వహించడం - 2 మినహాయింపు సంభవించవచ్చని ప్రోగ్రామర్ విశ్వసించే కోడ్ tryబ్లాక్‌లో ఉంచబడుతుంది. అంటే ఇక్కడ మినహాయింపు వస్తుందని కాదు. ఇది ఇక్కడ సంభవించవచ్చు మరియు ప్రోగ్రామర్‌కు ఈ అవకాశం గురించి తెలుసు. మీరు సంభవించే ఎర్రర్ రకం బ్లాక్‌లో ఉంచబడుతుంది catch. ఇది మినహాయింపు సంభవించినట్లయితే అమలు చేయవలసిన అన్ని కోడ్‌లను కూడా కలిగి ఉంటుంది. ఇక్కడ ఒక ఉదాహరణ: 

public static void main(String[] args) throws IOException {
   try {
       BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));

       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (FileNotFoundException e) {

       System.out.println("Error! File not found!");
   }
}
అవుట్‌పుట్: లోపం! ఫైల్ దొరకలేదు! మేము మా కోడ్‌ను రెండు బ్లాక్‌లలో ఉంచాము. మొదటి బ్లాక్‌లో, "ఫైల్ కనుగొనబడలేదు" లోపం సంభవించవచ్చని మేము అంచనా వేస్తున్నాము. ఇది tryబ్లాక్. రెండవది, లోపం సంభవించినట్లయితే ఏమి చేయాలో ప్రోగ్రామ్‌కు తెలియజేస్తాము. మరియు నిర్దిష్ట లోపం రకం: FileNotFoundException. మేము బ్లాక్ యొక్క కుండలీకరణాల్లో వేరే మినహాయింపు తరగతిని ఉంచినట్లయితే catch, అప్పుడు FileNotFoundExceptionక్యాచ్ చేయబడదు. 

public static void main(String[] args) throws IOException {
   try {
       BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));
       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (ArithmeticException e) {

       System.out.println("Error! File not found!");
   }
}
అవుట్‌పుట్: థ్రెడ్ "మెయిన్catch " java.io.FileNotFoundException పట్టుకోవడానికి ఈ బ్లాక్ ArithmeticException, మరియు బ్లాక్‌లోని కోడ్ tryవేరొక రకాన్ని విసిరింది: FileNotFoundException. నిర్వహించడానికి మేము ఏ కోడ్‌ను వ్రాయలేదు FileNotFoundException, కాబట్టి ప్రోగ్రామ్ కోసం డిఫాల్ట్ సమాచారాన్ని ప్రదర్శిస్తుంది FileNotFoundException. ఇక్కడ మీరు మూడు విషయాలపై దృష్టి పెట్టాలి. ప్రథమ. బ్లాక్‌లోని కొన్ని లైన్‌లో మినహాయింపు సంభవించిన తర్వాత try, అనుసరించే కోడ్ అమలు చేయబడదు. ప్రోగ్రామ్ యొక్క అమలు వెంటనే బ్లాక్కు "జంప్స్" catch. ఉదాహరణకి: 

public static void main(String[] args) {
   try {
       System.out.println("Divide by zero");
       System.out.println(366/0);// This line of code will throw an exception

       System.out.println("This");
       System.out.println("code");
       System.out.println("will not");
       System.out.println("be");
       System.out.println("executed!");

   } catch (ArithmeticException e) {

       System.out.println("The program jumped to the catch block!");
       System.out.println("Error! You can't divide by zero!");
   }
}
అవుట్‌పుట్: సున్నాతో భాగించండి ప్రోగ్రామ్ క్యాచ్ బ్లాక్‌కి వెళ్లింది! లోపం! మీరు సున్నాతో భాగించలేరు! బ్లాక్ యొక్క రెండవ పంక్తిలో try, మేము 0 ద్వారా విభజించడానికి ప్రయత్నిస్తాము, ఫలితంగా ArithmeticException. తత్ఫలితంగా, బ్లాక్ యొక్క 3-9 లైన్లు tryఅమలు చేయబడవు. మేము చెప్పినట్లుగా, ప్రోగ్రామ్ వెంటనే catchబ్లాక్‌ను అమలు చేయడం ప్రారంభిస్తుంది. సంఖ్య రెండు. అనేక బ్లాక్‌లు ఉండవచ్చు catch. బ్లాక్‌లోని కోడ్ tryఒకటి కాదు, అనేక రకాల మినహాయింపులను విసిరితే, మీరు catchవాటిలో ప్రతిదానికి ఒక బ్లాక్‌ని వ్రాయవచ్చు. 

public static void main(String[] args) throws IOException {
   try {
       BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));

       System.out.println(366/0);
       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (FileNotFoundException e) {
      
       System.out.println("Error! File not found!");
      
   } catch (ArithmeticException e) {

       System.out.println("Error! Division by 0!");
      
   }
}
ఈ ఉదాహరణలో, మేము రెండు catchబ్లాక్‌లను వ్రాసాము. ఒక బ్లాక్‌లో FileNotFoundExceptionసంభవించినట్లయితే try, మొదటి catchబ్లాక్ అమలు చేయబడుతుంది. సంభవించినట్లయితే ArithmeticException, రెండవ బ్లాక్ అమలు చేయబడుతుంది. catchమీరు కావాలనుకుంటే మీరు 50 బ్లాక్‌లను వ్రాయవచ్చు . అయితే, 50 రకాల మినహాయింపులను విసిరే కోడ్‌ను వ్రాయకపోవడమే మంచిది. :) మూడవది. మీ కోడ్ ఏయే మినహాయింపులను అందించవచ్చో మీకు ఎలా తెలుసు? సరే, మీరు వాటిలో కొన్నింటిని ఊహించగలరు, కానీ మీరు మీ తలపై ప్రతిదీ ఉంచుకోవడం అసాధ్యం. అందువల్ల జావా కంపైలర్‌కు అత్యంత సాధారణ మినహాయింపులు మరియు అవి సంభవించే పరిస్థితుల గురించి తెలుసు. ఉదాహరణకు, మీరు కంపైలర్‌కు రెండు రకాల మినహాయింపులను అందించవచ్చని తెలిసిన కోడ్‌ను వ్రాస్తే, మీరు వాటిని నిర్వహించే వరకు మీ కోడ్ కంపైల్ చేయదు. మేము దీనికి ఉదాహరణలను క్రింద చూస్తాము. ఇప్పుడు మినహాయింపు నిర్వహణ గురించి కొన్ని మాటలు. మినహాయింపులను నిర్వహించడానికి 2 మార్గాలు ఉన్నాయి. మేము ఇప్పటికే మొదటిదాన్ని ఎదుర్కొన్నాము: పద్ధతి ఒక బ్లాక్‌లో మినహాయింపును నిర్వహించగలదు catch(). రెండవ ఎంపిక ఉంది: పద్ధతి కాల్ స్టాక్‌పై మినహాయింపును తిరిగి విసిరివేయగలదు. అంటే ఏమిటి? ఉదాహరణకు, మేము అదే printFirstString()పద్ధతితో ఒక తరగతిని కలిగి ఉన్నాము, ఇది ఫైల్‌ను చదివి దాని మొదటి పంక్తిని ప్రదర్శిస్తుంది: 

public static void printFirstString(String filePath) {

   BufferedReader reader = new BufferedReader(new FileReader(filePath));
   String firstString = reader.readLine();
   System.out.println(firstString);
}
ప్రస్తుతం, మా కోడ్ కంపైల్ చేయబడలేదు, ఎందుకంటే దీనికి హ్యాండిల్ చేయని మినహాయింపులు ఉన్నాయి. లైన్ 1లో, మీరు ఫైల్‌కు మార్గాన్ని పేర్కొనండి. అటువంటి కోడ్ సులభంగా ఒక ఉత్పత్తి చేయగలదని కంపైలర్‌కు తెలుసు FileNotFoundException. 3వ వరుసలో, మీరు ఫైల్ నుండి వచనాన్ని చదివారు. ఈ ప్రక్రియ సులభంగా (ఇన్‌పుట్/అవుట్‌పుట్ లోపం)కి దారితీయవచ్చు IOException. ఇప్పుడు కంపైలర్ మీతో ఇలా అన్నాడు, "డ్యూడ్, నేను ఈ కోడ్‌ని ఆమోదించను మరియు ఈ మినహాయింపులలో ఒకటి సంభవించినట్లయితే నేను ఏమి చేయాలో మీరు చెప్పే వరకు నేను దానిని కంపైల్ చేయను. మరియు మీరు వ్రాసిన కోడ్ ఆధారంగా అవి ఖచ్చితంగా జరగవచ్చు. !" దాని చుట్టూ తిరగడానికి మార్గం లేదు: మీరు రెండింటినీ నిర్వహించాలి! మొదటి మినహాయింపు నిర్వహణ పద్ధతి గురించి మాకు ఇప్పటికే తెలుసు: మేము మా కోడ్‌ను ఒక బ్లాక్‌లో ఉంచాలి tryమరియు రెండు catchబ్లాక్‌లను జోడించాలి: 

public static void printFirstString(String filePath) {

   try {
       BufferedReader reader = new BufferedReader(new FileReader(filePath));
       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (FileNotFoundException e) {
       System.out.println("Error, file not found!");
       e.printStackTrace();
   } catch (IOException e) {
       System.out.println("File input/output error!");
       e.printStackTrace();
   }
}
కానీ ఇది ఏకైక ఎంపిక కాదు. మేము పద్ధతిలో లోపం-నిర్వహణ కోడ్‌ను వ్రాయడానికి బదులుగా మినహాయింపును ఎక్కువగా విసిరివేయవచ్చు. throwsఇది మెథడ్ డిక్లరేషన్‌లోని కీవర్డ్‌ని ఉపయోగించి చేయబడుతుంది : 

public static void printFirstString(String filePath) throws FileNotFoundException, IOException {
   BufferedReader reader = new BufferedReader(new FileReader(filePath));
   String firstString = reader.readLine();
   System.out.println(firstString);
}
కీవర్డ్ తర్వాత throws, మేము పద్ధతి విసిరే అన్ని రకాల మినహాయింపుల యొక్క కామాతో వేరు చేయబడిన జాబితాను సూచిస్తాము. ఎందుకు? ఇప్పుడు, ఎవరైనా ప్రోగ్రామ్‌లోని పద్ధతిని కాల్ చేయాలనుకుంటే printFirstString(), అతను లేదా ఆమె (మీరు కాదు) మినహాయింపు నిర్వహణను అమలు చేయాలి. ఉదాహరణకు, ప్రోగ్రామ్‌లో ఎక్కడైనా మీ సహోద్యోగులలో ఒకరు మీ printFirstString()పద్ధతిని పిలిచే పద్ధతిని వ్రాసారని అనుకుందాం: 

public static void yourColleagueMethod() {

   // Your colleague's method does something

   //...and then calls your printFirstString() method with the file it needs
   printFirstString("C:\\Users\\Henry\\Desktop\\testFile.txt");
}
మాకు లోపం వస్తుంది! ఈ కోడ్ కంపైల్ చేయదు! మేము పద్ధతిలో మినహాయింపు-నిర్వహణ కోడ్‌ని వ్రాయలేదు printFirstString(). ఫలితంగా, ఈ పని ఇప్పుడు పద్ధతిని ఉపయోగించే వారి భుజాలపై పడుతోంది. మరో మాటలో చెప్పాలంటే, పద్ధతి ఇప్పుడు అదే 2 ఎంపికలను కలిగి ఉంది: ఇది రెండు మినహాయింపులను నిర్వహించడానికి methodWrittenByYourColleague()ఒక బ్లాక్‌ని ఉపయోగించాలి లేదా వాటిని మళ్లీ విసిరేయాలి.try-catch 

public static void yourColleagueMethod() throws FileNotFoundException, IOException {
   // The method does something

   //...and then calls your printFirstString() method with the file it needs
   printFirstString("C:\\Users\\Henry\\Desktop\\testFile.txt");
}
రెండవ సందర్భంలో, కాల్ స్టాక్‌లోని తదుపరి పద్ధతి-కాలింగ్ చేసేది methodWrittenByYourColleague()- మినహాయింపులను నిర్వహించాలి. అందుకే దీనిని "త్రోయింగ్ లేదా పాస్ ది ఎక్సెప్షన్ అప్" అంటాము. మీరు కీవర్డ్ ఉపయోగించి మినహాయింపులను పైకి విసిరితే throws, మీ కోడ్ కంపైల్ అవుతుంది. ఈ సమయంలో, కంపైలర్, "సరే, సరే. మీ కోడ్ సంభావ్య మినహాయింపుల సమూహాన్ని కలిగి ఉంది, కానీ నేను దానిని కంపైల్ చేస్తాను. అయితే మేము ఈ సంభాషణకు తిరిగి వస్తాము!" మరియు మీరు నిర్వహించని మినహాయింపులను కలిగి ఉన్న ఏదైనా పద్ధతిని కాల్ చేసినప్పుడు, కంపైలర్ దాని వాగ్దానాన్ని నెరవేరుస్తుంది మరియు వాటి గురించి మీకు మళ్లీ గుర్తు చేస్తుంది. చివరగా, మేము బ్లాక్ గురించి మాట్లాడుతాము finally(పన్ కోసం క్షమించండి). ఇది మినహాయింపు నిర్వహణ ట్రిమ్‌వైరేట్‌లో చివరి భాగం try-catch-finally.. 

public static void main(String[] args) throws IOException {
   try {
       BufferedReader reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));

       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (FileNotFoundException e) {
       System.out.println("Error! File not found!");
       e.printStackTrace();
   } finally {
       System.out.println ("And here's the finally block!");
   }
}
ఈ ఉదాహరణలో, బ్లాక్ లోపల కోడ్ finallyరెండు సందర్భాల్లోనూ అమలు చేయబడుతుంది. బ్లాక్‌లోని కోడ్ tryఎటువంటి మినహాయింపులు లేకుండా పూర్తిగా రన్ అయితే, finallyబ్లాక్ చివరికి రన్ అవుతుంది. బ్లాక్ లోపల ఉన్న కోడ్‌కు tryమినహాయింపు ద్వారా అంతరాయం ఏర్పడి, ప్రోగ్రామ్ catchబ్లాక్‌కి దూకినట్లయితే, finallyబ్లాక్ లోపల ఉన్న కోడ్ తర్వాత బ్లాక్ రన్ అవుతుంది catch. ఇది ఎందుకు అవసరం? తప్పనిసరి కోడ్‌ని అమలు చేయడం దీని ప్రధాన ఉద్దేశ్యం: పరిస్థితులతో సంబంధం లేకుండా తప్పనిసరిగా నిర్వహించాల్సిన కోడ్. ఉదాహరణకు, ప్రోగ్రామ్ ఉపయోగించే కొన్ని వనరులను ఇది తరచుగా ఖాళీ చేస్తుంది. మా కోడ్‌లో, ఫైల్ నుండి సమాచారాన్ని చదవడానికి మరియు దానిని BufferedReaderఆబ్జెక్ట్‌కు పంపడానికి మేము స్ట్రీమ్‌ను తెరుస్తాము. మేము మా రీడర్‌ను మూసివేయాలి మరియు వనరులను విడుదల చేయాలి. ఇది ఏమైనప్పటికీ చేయాలి-ప్రోగ్రామ్ ఎప్పుడు పని చేస్తుందో మరియు అది మినహాయింపును ఇచ్చినప్పుడు. దీన్ని చేయడానికి బ్లాక్ finallyచాలా అనుకూలమైన ప్రదేశం: 

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

   BufferedReader reader = null;
   try {
       reader = new BufferedReader(new FileReader("C:\\Users\\Username\\Desktop\\test.txt"));

       String firstString = reader.readLine();
       System.out.println(firstString);
   } catch (FileNotFoundException e) {
       e.printStackTrace();
   } finally {
       System.out.println ("And here's the finally block!");
       if (reader != null) {
           reader.close();
       }
   }
}
ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు ఏమి జరుగుతుందనే దానితో సంబంధం లేకుండా మేము వనరులను జాగ్రత్తగా చూసుకుంటామని ఇప్పుడు మేము నిశ్చయించుకున్నాము. :) మినహాయింపుల గురించి మీరు తెలుసుకోవలసినది అంతే కాదు. ప్రోగ్రామింగ్‌లో ఎర్రర్ హ్యాండ్లింగ్ అనేది చాలా ముఖ్యమైన అంశం. చాలా వ్యాసాలు దీనికి అంకితం చేయబడ్డాయి. తర్వాతి పాఠంలో, ఎలాంటి మినహాయింపులు ఉన్నాయి మరియు మీ స్వంత మినహాయింపులను ఎలా సృష్టించాలో మేము కనుగొంటాము. :) మరలా కలుద్దాం!

మరింత పఠనం: