ஜாவாவில் விதிவிலக்குகள்

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

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

நிரலாக்க உலகில், ஒரு நிரலை செயல்படுத்துவதில் ஏற்படும் பிழைகள் மற்றும் எதிர்பாராத சூழ்நிலைகள் விதிவிலக்குகள் என்று அழைக்கப்படுகின்றன. ஒரு நிரலில், தவறான பயனர் செயல்கள், போதுமான வட்டு இடம் அல்லது சேவையகத்துடன் பிணைய இணைப்பு இழப்பு போன்றவற்றால் விதிவிலக்குகள் ஏற்படலாம். விதிவிலக்குகள் நிரலாக்கப் பிழைகள் அல்லது API இன் தவறான பயன்பாடு ஆகியவற்றாலும் ஏற்படலாம். நிஜ உலகில் உள்ள மனிதர்களைப் போலல்லாமல், இந்த சூழ்நிலைகளை எவ்வாறு கையாள்வது என்பதை ஒரு நிரல் சரியாக அறிந்திருக்க வேண்டும். இதற்கு, ஜாவாவில் விதிவிலக்கு கையாளுதல் எனப்படும் ஒரு பொறிமுறை உள்ளது.

முக்கிய வார்த்தைகள் பற்றி சில வார்த்தைகள்

ஜாவாவில் விதிவிலக்கு கையாளுதல் நிரலில் பின்வரும் முக்கிய வார்த்தைகளின் பயன்பாட்டை அடிப்படையாகக் கொண்டது:

• முயற்சி - விதிவிலக்கு ஏற்படக்கூடிய குறியீட்டின் தொகுதியை வரையறுக்கிறது;
• கேட்ச் - விதிவிலக்குகள் கையாளப்படும் குறியீட்டின் தொகுதியை வரையறுக்கிறது;
• இறுதியாக - ட்ரை பிளாக்கின் முடிவுகளைப் பொருட்படுத்தாமல் செயல்படுத்தப்படும் குறியீட்டின் விருப்பத் தொகுதியை வரையறுக்கிறது.

குறியீட்டில் சிறப்புக் கட்டமைப்பை உருவாக்க இந்த முக்கிய வார்த்தைகள் பயன்படுத்தப்படுகின்றன: முயற்சி{}பிடிக்க , முயற்சி{}பிடிக்க{}இறுதியாக , முயற்சி{}இறுதியாக{} .

• தூக்கி - ஒரு விதிவிலக்கு எழுப்ப பயன்படுகிறது;
• எறிதல் - முறை விதிவிலக்கு எறியலாம் என்று எச்சரிக்க முறை கையொப்பத்தில் பயன்படுத்தப்படுகிறது.

ஜாவா நிரலில் முக்கிய வார்த்தைகளைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn 
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the 
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException  
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

நமக்கு ஏன் விதிவிலக்குகள் தேவை?

நிஜ உலகத்திலிருந்து ஒரு உதாரணத்தைப் பார்ப்போம். நெடுஞ்சாலையின் ஒரு பகுதியில் குறைந்த எடை திறன் கொண்ட சிறிய பாலம் இருப்பதாக கற்பனை செய்து பாருங்கள். பாலத்தின் வரம்பை விட கனமான கார் அதன் மீது செலுத்தினால், அது இடிந்து விழும். ஓட்டுநரின் நிலைமை லேசாகச் சொல்வதானால், விதிவிலக்கானதாக மாறும். இதை தவிர்க்க, போக்குவரத்து துறையினர், அசம்பாவிதம் ஏற்படும் முன், சாலையில், எச்சரிக்கை பலகைகளை நிறுவுகின்றனர். எச்சரிக்கை பலகையைப் பார்த்து, ஒரு ஓட்டுநர் தனது வாகனத்தின் எடையை பாலத்தின் அதிகபட்ச எடையுடன் ஒப்பிடுகிறார். வாகனம் மிகவும் கனமாக இருந்தால், ஓட்டுநர் பைபாஸ் பாதையில் செல்கிறார். போக்குவரத்துத் துறை, முதலில், லாரி ஓட்டுநர்கள் தேவைப்பட்டால் தங்கள் வழியை மாற்றுவதை சாத்தியமாக்கியது, இரண்டாவதாக, பிரதான சாலையில் ஏற்படும் ஆபத்துகள் குறித்து டிரைவர்களை எச்சரித்தது, மூன்றாவது, சில நிபந்தனைகளின் கீழ் பாலத்தை பயன்படுத்தக்கூடாது என்று டிரைவர்களை எச்சரித்தது. ஒரு நிரலில் உள்ள விதிவிலக்கான சூழ்நிலைகளைத் தடுக்கும் மற்றும் தீர்க்கும் திறன், அதை தொடர்ந்து இயங்க அனுமதிப்பது, ஜாவாவில் விதிவிலக்குகளைப் பயன்படுத்துவதற்கான ஒரு காரணமாகும். விதிவிலக்கு பொறிமுறையானது எந்த உள்ளீடுகளையும் சரிபார்ப்பதன் மூலம் (சரிபார்ப்பதன் மூலம்) முறையற்ற பயன்பாட்டில் இருந்து உங்கள் குறியீட்டை (API) பாதுகாக்க உதவுகிறது. இப்போது நீங்கள் ஒரு நொடி போக்குவரத்து துறை என்று கற்பனை செய்து பாருங்கள். முதலில், வாகன ஓட்டிகள் சிக்கலை எதிர்பார்க்கக்கூடிய இடங்களை நீங்கள் அறிந்து கொள்ள வேண்டும். இரண்டாவதாக, நீங்கள் எச்சரிக்கை அறிகுறிகளை உருவாக்கி நிறுவ வேண்டும். இறுதியாக, பிரதான பாதையில் சிக்கல்கள் ஏற்பட்டால் நீங்கள் மாற்றுப்பாதைகளை வழங்க வேண்டும். ஜாவாவில், விதிவிலக்கு பொறிமுறையானது இதே வழியில் செயல்படுகிறது. மேம்பாட்டின் போது, ​​குறியீட்டின் ஆபத்தான பிரிவுகளைச் சுற்றி "விதிவிலக்கு தடைகளை" உருவாக்க முயற்சித் தடுப்பைப் பயன்படுத்துகிறோம் , கேட்ச் {}ஐப் பயன்படுத்தி "காப்பு வழிகளை" வழங்குகிறோம்.ப்ளாக், மற்றும் கடைசியாக{} பிளாக்கில் எதுவாக இருந்தாலும் இயங்க வேண்டிய குறியீட்டை எழுதுகிறோம் . எங்களால் "காப்புப் பாதையை" வழங்க முடியாவிட்டால் அல்லது பயனருக்குத் தேர்ந்தெடுக்கும் உரிமையை வழங்க விரும்பினால், குறைந்தபட்சம் அவருக்கு அல்லது அவளுக்கு ஆபத்தைப் பற்றி எச்சரிக்க வேண்டும். ஏன்? ஒரு எச்சரிக்கை பலகையைக் கூட பார்க்காமல், தன்னால் கடக்க முடியாத ஒரு சிறிய பாலத்தை அடையும் ஒரு ஓட்டுநரின் கோபத்தை கற்பனை செய்து பாருங்கள்! நிரலாக்கத்தில், எங்கள் வகுப்புகள் மற்றும் முறைகளை எழுதும் போது, ​​மற்ற டெவலப்பர்களால் அவை எவ்வாறு பயன்படுத்தப்படலாம் என்பதை எங்களால் எப்போதும் கணிக்க முடியாது. இதன் விளைவாக, ஒரு விதிவிலக்கான சூழ்நிலையைத் தீர்ப்பதற்கான 100% சரியான வழியை எங்களால் கணிக்க முடியாது. விதிவிலக்கான சூழ்நிலைகளின் சாத்தியக்கூறுகள் குறித்து மற்றவர்களை எச்சரிப்பது நல்ல வடிவம் என்று கூறினார். ஜாவாவின் விதிவிலக்கு பொறிமுறையானது வீசுதல்களுடன் இதைச் செய்ய உதவுகிறதுமுக்கிய வார்த்தை - அடிப்படையில் எங்கள் முறையின் பொதுவான நடத்தை விதிவிலக்குகளை வீசுவதை உள்ளடக்கியது என்ற அறிவிப்பு. எனவே, முறையைப் பயன்படுத்தும் எவருக்கும் விதிவிலக்குகளைக் கையாள குறியீட்டை எழுத வேண்டும் என்பது தெரியும்.

"சிக்கல்" பற்றி மற்றவர்களை எச்சரித்தல்

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

விதிவிலக்கு படிநிலை

ஒரு நிரல் இயங்கும் போது பிழை ஏற்பட்டால், JVM ஆனது ஜாவா விதிவிலக்கு படிநிலையில் இருந்து பொருத்தமான வகையின் பொருளை உருவாக்குகிறது - இது ஒரு பொதுவான மூதாதையரின் வழித்தோன்றல் சாத்தியமான விதிவிலக்குகளின் தொகுப்பு - வீசக்கூடிய வர்க்கம் . விதிவிலக்கான இயக்க நேர சூழ்நிலைகளை நாம் இரண்டு குழுக்களாகப் பிரிக்கலாம்:

1. நிரல் மீட்டெடுக்க முடியாத மற்றும் இயல்பான செயல்பாட்டைத் தொடர முடியாத சூழ்நிலைகள்.
2. மீட்பு சாத்தியமான சூழ்நிலைகள்.

முதல் குழுவில் பிழை வகுப்பில் இருந்து வரும் விதிவிலக்கு சம்பந்தப்பட்ட சூழ்நிலைகள் அடங்கும். இவை JVM செயலிழப்பு, நினைவக வழிதல் அல்லது கணினி செயலிழப்பு காரணமாக ஏற்படும் பிழைகள். அவை பொதுவாக மென்பொருளால் சரிசெய்ய முடியாத கடுமையான சிக்கல்களைக் குறிக்கின்றன. ஜாவாவில், அத்தகைய விதிவிலக்குகளின் சாத்தியம் கம்பைலரால் சரிபார்க்கப்படவில்லை, எனவே அவை சரிபார்க்கப்படாத விதிவிலக்குகள் என்று அழைக்கப்படுகின்றன. இந்த குழுவில் RuntimeExceptions அடங்கும், அவை விதிவிலக்கிலிருந்து வரும் விதிவிலக்குகள்வகுப்பு மற்றும் இயக்க நேரத்தில் JVM ஆல் உருவாக்கப்படுகின்றன. அவை பெரும்பாலும் நிரலாக்க பிழைகளால் ஏற்படுகின்றன. தொகுக்கும் நேரத்தில் இந்த விதிவிலக்குகள் சரிபார்க்கப்படாது (தேர்வு செய்யப்படவில்லை), எனவே அவற்றைக் கையாள நீங்கள் குறியீட்டை எழுத வேண்டிய அவசியமில்லை. இரண்டாவது குழுவில் நீங்கள் நிரலை எழுதும் போது முன்னறிவிக்கக்கூடிய விதிவிலக்கான சூழ்நிலைகள் உள்ளன (இதனால் அவற்றைக் கையாள நீங்கள் குறியீட்டை எழுத வேண்டும்). இத்தகைய விதிவிலக்குகள் சரிபார்க்கப்பட்ட விதிவிலக்குகள் என்று அழைக்கப்படுகின்றன. விதிவிலக்குகளுக்கு வரும்போது, ​​ஜாவா டெவலப்பரின் பெரும்பாலான வேலைகள் இதுபோன்ற சூழ்நிலைகளைக் கையாளுகின்றன.

விதிவிலக்கை உருவாக்குதல்

ஒரு நிரல் இயங்கும் போது, ​​விதிவிலக்குகள் JVM அல்லது கைமுறையாக வீசுதல் அறிக்கையைப் பயன்படுத்தி உருவாக்கப்படும். இது நிகழும்போது, ​​நினைவகத்தில் ஒரு விதிவிலக்கு பொருள் உருவாக்கப்படுகிறது, நிரலின் முக்கிய ஓட்டம் குறுக்கிடப்படுகிறது, மேலும் JVM இன் விதிவிலக்கு ஹேண்ட்லர் விதிவிலக்கைக் கையாள முயற்சிக்கிறது.

விதிவிலக்கு கையாளுதல்

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

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

முக்கிய முறையின் முடிவுகள் இங்கே :

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

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

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

பதிப்பு 7 இல் அறிமுகப்படுத்தப்பட்ட ஜாவா திறன்களுக்கு நன்றி, பன்முகத்தன்மை வாய்ந்த விதிவிலக்குகளைப் பிடிப்பதை ஒரு தொகுதியாக இணைக்கலாம், மேலும் குறியீட்டை மிகவும் கச்சிதமாகவும் படிக்கக்கூடியதாகவும் மாற்றலாம். உதாரணமாக:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

அடிக்கோடு

ஜாவாவில் விதிவிலக்குகளைப் பயன்படுத்துவது, "காப்புப் பாதைகளை" உருவாக்குவதன் மூலம் உங்கள் நிரல்களை மேலும் வலுவாக மாற்ற உதவுகிறது, விதிவிலக்கு கையாளுதல் குறியீட்டிலிருந்து முக்கிய குறியீட்டைப் பிரிக்க கேட்ச் பிளாக்குகளைப் பயன்படுத்தவும், மேலும் உங்கள் முறையைப் பயன்படுத்துபவர்களுக்கு விதிவிலக்குக் கையாளுதலுக்கான பொறுப்பை மாற்ற த்ரோகளைப் பயன்படுத்தவும்.