விதிவிலக்குகள்: பிடிப்பது மற்றும் கையாளுதல்

வணக்கம்! நான் அதை குறிப்பிட வெறுக்கிறேன், ஆனால் ஒரு புரோகிராமரின் பணியின் பெரும்பகுதி பிழைகளை கையாள்கிறது. பெரும்பாலும், அவரது சொந்த. தவறு செய்யாதவர்களே இல்லை என்பது புலனாகிறது. மேலும் அத்தகைய திட்டங்கள் எதுவும் இல்லை. நிச்சயமாக, ஒரு பிழையை கையாளும் போது, ​​முக்கிய விஷயம் அதன் காரணத்தை புரிந்து கொள்ள வேண்டும். மற்றும் நிறைய விஷயங்கள் ஒரு நிரலில் பிழைகளை ஏற்படுத்தும். சில சமயங்களில், ஜாவாவின் படைப்பாளிகள் பெரும்பாலும் நிரலாக்கப் பிழைகள் இருந்தால் என்ன செய்ய வேண்டும் என்று தங்களைத் தாங்களே கேட்டுக் கொண்டனர்? அவற்றை முற்றிலுமாகத் தவிர்ப்பது யதார்த்தமானது அல்ல, நீங்கள் நினைத்துக்கூடப் பார்க்க முடியாத விஷயங்களை புரோகிராமர்கள் எழுதும் திறன் கொண்டவர்கள். :) எனவே, பிழைகளுடன் வேலை செய்வதற்கான ஒரு பொறிமுறையை மொழிக்கு வழங்க வேண்டும். வேறு வார்த்தைகளில் கூறுவதானால், உங்கள் திட்டத்தில் பிழை இருந்தால், அடுத்து என்ன செய்ய வேண்டும் என்பதற்கு உங்களுக்கு ஒருவித ஸ்கிரிப்ட் தேவை. பிழை ஏற்பட்டால் ஒரு நிரல் சரியாக என்ன செய்ய வேண்டும்? இன்று நாம் இந்த பொறிமுறையைப் பற்றி அறிந்து கொள்வோம். இது " ஜாவாவில் விதிவிலக்குகள் " என்று அழைக்கப்படுகிறது.

விதிவிலக்கு என்ன?

விதிவிலக்கு என்பது ஒரு நிரல் இயங்கும் போது ஏற்படும் ஒரு விதிவிலக்கான, திட்டமிடப்படாத சூழ்நிலையாகும். பல விதிவிலக்குகள் உள்ளன. எடுத்துக்காட்டாக, ஒரு கோப்பிலிருந்து உரையைப் படிக்கும் மற்றும் முதல் வரியைக் காண்பிக்கும் குறியீட்டை நீங்கள் எழுதியுள்ளீர்கள்.

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. விதிவிலக்கு ஏற்படலாம் என்று புரோகிராமர் நம்பும் குறியீடு தொகுதியில் வைக்கப்படுகிறது 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!");
   }
}

வெளியீடு: நூல் "முக்கிய" java.io.FileNotFoundException: C:\Users\Username\Desktop\test.txt (கணினியால் குறிப்பிட்ட பாதையைக் கண்டறிய முடியவில்லை) பிளாக்கில் உள்ள குறியீடு catchஇயங்கவில்லை, ஏனெனில் நாங்கள் "கட்டமைத்துள்ளோம்" இந்த தொகுதியை பிடிக்க 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(). இதன் விளைவாக, இந்த பணி இப்போது முறையைப் பயன்படுத்துபவர்களின் தோள்களில் விழுகிறது. வேறு வார்த்தைகளில் கூறுவதானால், methodWrittenByYourColleague()முறை இப்போது அதே 2 விருப்பங்களைக் கொண்டுள்ளது: 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();
       }
   }
}

நிரல் இயங்கும்போது என்ன நடந்தாலும், ஆதாரங்களை நாங்கள் கவனித்துக்கொள்வோம் என்பதில் உறுதியாக உள்ளோம். :) விதிவிலக்குகள் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டியது அவ்வளவுதான். நிரலாக்கத்தில் பிழை கையாளுதல் ஒரு மிக முக்கியமான தலைப்பு. நிறைய கட்டுரைகள் அதற்கு அர்ப்பணிக்கப்பட்டுள்ளன. அடுத்த பாடத்தில், என்ன வகையான விதிவிலக்குகள் உள்ளன மற்றும் உங்கள் சொந்த விதிவிலக்குகளை எவ்வாறு உருவாக்குவது என்பதைக் கண்டுபிடிப்போம். :) பிறகு பார்க்கலாம்!