விதிவிலக்குகளை அறிமுகப்படுத்துகிறது

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

1. ஹார்ட் டிரைவ் முழுவதுமாக நிரம்பியவுடன் நிரல் ஒரு கோப்பை எழுத முயற்சி செய்யலாம்.

2. நிரல் ஒரு மாறியில் ஒரு முறையை அழைக்க முயற்சி செய்யலாம்.

3. நிரல் ஒரு எண்ணை 0 ஆல் வகுக்க முயற்சி செய்யலாம்."

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

"ஏன்?"

"கார் சாலையில் இருந்து விலகி ஒரு குன்றின் மீது விழுந்தால், சக்கரத்தைத் திருப்பிக் கொண்டிருப்பதில் அர்த்தமா?"

"அப்படியானால், நிரல் இயங்குவதை நிறுத்த வேண்டுமா?"

ஆம் _

"இது மிகவும் புத்திசாலித்தனமான அணுகுமுறை."

"ஆனால் நிரலைத் தொடர்ந்து இயக்க முயற்சிப்பது நல்லது அல்லவா?"

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

"ஆமாம்."

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

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

"சரி. நானும் அதைத்தான் நினைச்சேன்."

"பின்னர், ஒரு பிரகாசமான எதிர்காலம் விதிவிலக்குகள் மற்றும் பிழை-கையாளுதல் பொறிமுறையின் வடிவத்தில் வந்தது. இது எவ்வாறு செயல்படுகிறது என்பது இங்கே:

1. பிழை ஏற்பட்டால், ஜாவா இயந்திரம் ஒரு சிறப்புப் பொருளை உருவாக்குகிறது - ஒரு விதிவிலக்கு - அது அனைத்து பிழைத் தகவலையும் சேமிக்கிறது. வெவ்வேறு பிழைகளுக்கு வெவ்வேறு விதிவிலக்குகள் உள்ளன.

2. ஒரு விதிவிலக்கு நிரல் தற்போதைய செயல்பாட்டிலிருந்து உடனடியாக வெளியேறுகிறது, மேலும் அடுத்த செயல்பாடு, மற்றும் பல - அது முக்கிய முறையிலிருந்து வெளியேறும் வரை. பின்னர் நிரல் முடிவடைகிறது. ஜாவா மெஷின் 'அழைப்பு அடுக்கை அவிழ்க்கிறது' என்றும் புரோகிராமர்கள் கூறலாம்."

"ஆனால் நிரல் எப்போதும் முடிவடையாது என்று நீங்கள் சொன்னீர்கள்."

"ஆமாம், விதிவிலக்கைப் பிடிக்க ஒரு வழி இருப்பதால். நாம் விரும்பும் விதிவிலக்குகளைப் பிடிக்கவும் அவற்றைக் கொண்டு ஏதாவது செய்யவும் சரியான இடத்தில் சிறப்புக் குறியீட்டை எழுதலாம். இது முக்கியமான விஷயம்."

"இதைச் செய்ய எங்களுக்கு உதவ, ஒரு சிறப்பு முயற்சி-பிடிப்பு கட்டுமானம் உள்ளது . இது எப்படி வேலை செய்கிறது:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (Exception e)
        {
           System.out.println("Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

Program starts
Before method1 calling
Exception has been caught
Program is still running

"ஆனால் 'அழைப்பு முறை1. இது ஒருபோதும் காட்டப்படாது' ஏன் திரையில் காட்டப்படாது?"

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

"விதிவிலக்கு method1முறையின் உள்ளே நிகழ்கிறது. இது முறை உடனடியாக நிறுத்தப்படுவதற்கு காரணமாகிறது. இது முயற்சி-பிடிப்புத் தடுப்புக்காக இல்லாவிட்டால், முக்கிய முறை நிறுத்தப்படும் ."

" டிரை பிளாக்கிற்குள் விதிவிலக்கு ஏற்பட்டால் , அது கேட்ச் பிளாக்கில் பிடிபடும் . டிரை பிளாக்கில் உள்ள மீதமுள்ள குறியீடு செயல்படுத்தப்படாது. மாறாக, கேட்ச் பிளாக் செயல்படுத்தத் தொடங்கும். "

"எனக்கு புரியவில்லை."

"வேறு வார்த்தைகளில் கூறுவதானால், குறியீடு இதுபோல் செயல்படுகிறது:

1. ட்ரை பிளாக்கிற்குள் விதிவிலக்கு ஏற்பட்டால் , விதிவிலக்கு ஏற்பட்ட இடத்தில் குறியீடு செயல்படுத்தப்படுவது நிறுத்தப்பட்டு, கேட்ச் பிளாக் செயல்படுத்தத் தொடங்கும்.

2. விதிவிலக்கு ஏற்படவில்லை என்றால், முயற்சித் தொகுதி இறுதிவரை செயல்படுத்தப்படும் , மேலும் கேட்ச் பிளாக் செயல்படுத்தப்படாது. "

"ஆமா?"

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

"இப்போது கிடைத்துவிட்டது என்று நினைக்கிறேன்."

"சிறந்தது."

"விதிவிலக்கு' என்பது கேட்ச் ஸ்டேட்மென்ட்டுக்குள் என்ன அர்த்தம்?"

" எல்லா விதிவிலக்குகளும் விதிவிலக்கு வகுப்பைப் பெறும் வகுப்புகள். கேட்ச் பிளாக்கில் விதிவிலக்கு வகுப்பைக் குறிப்பிடுவதன் மூலம் ஒரு குறிப்பிட்ட விதிவிலக்கைப் பிடிக்கலாம் அல்லது அவற்றின் பொதுவான பெற்றோர் வகுப்பைக் குறிப்பிடுவதன் மூலம் அனைத்து விதிவிலக்குகளையும் பிடிக்கலாம் - விதிவிலக்கு. பின்னர் தேவையான அனைத்து பிழைகளையும் நாம் பெறலாம். e மாறியிலிருந்து தகவல் (இது விதிவிலக்கு பொருளின் குறிப்பைச் சேமிக்கிறது)."

"அருமை! எனது முறையில் வெவ்வேறு விதிவிலக்குகள் ஏற்பட்டால், நான் அவற்றை வேறுவிதமாகச் செயல்படுத்தலாமா?"

"உங்களால் முடியாது, ஆனால் நீங்கள் செய்ய வேண்டும். நீங்கள் அதை இப்படி செய்யலாம்:"

public class ExceptionExample2
{
    public static void main(String[] args)
    {
        System.out.println("Program starts");

        try
        {
            System.out.println("Before calling method1");
            method1();
            System.out.println("After calling method1. This will never be shown");
        }
        catch (NullPointerException e)
        {
           System.out.println("Null reference. Exception has been caught");
        }
        catch (ArithmeticException e)
        {
            System.out.println("Division by zero. Exception has been caught");
        }
        catch (Exception e)
        {
            System.out.println("Any other errors. Exception has been caught");
        }

        System.out.println("Program is still running");
    }

    public static void method1()
    {
        int a = 100;
        int b = 0;
        System.out.println(a / b);
    }
}

" டிரை பிளாக் பல கேட்ச் பிளாக்குகளுடன் இணைக்கப்படலாம் , அவை ஒவ்வொன்றும் குறிப்பிட்ட வகை விதிவிலக்குகளைப் பிடிக்கும்."

"புரிகிறது என்று நினைக்கிறேன். என்னால் இன்னும் இதை எழுத முடியாது, ஆனால் நான் அதை குறியீட்டில் கண்டால், நான் பயப்பட மாட்டேன்."