మినహాయింపులను పరిచయం చేస్తున్నాము

"హాయ్, అమిగో. మేము ఈ రోజు చాలా ఆసక్తికరమైన పాఠాన్ని కలిగి ఉన్నాము. నేను మీకు మినహాయింపుల గురించి చెప్పబోతున్నాను. మినహాయింపులు అనేది ప్రోగ్రామ్‌లో లోపాలను నిర్వహించడానికి మాకు అనుమతించే ఒక ప్రత్యేక మెకానిజం. సంభవించే లోపాల యొక్క కొన్ని ఉదాహరణలు ఇక్కడ ఉన్నాయి. ఒక కార్యక్రమంలో:

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);
    }
}

" ట్రై బ్లాక్‌ను అనేక క్యాచ్ బ్లాక్‌లతో జత చేయవచ్చు , వీటిలో ప్రతి ఒక్కటి పేర్కొన్న రకాల మినహాయింపులను క్యాచ్ చేస్తుంది."

"నాకు అర్థమైందని అనుకుంటున్నాను. ఇది నేనే ఇంకా వ్రాయలేను, కానీ నేను కోడ్‌లో కనిపిస్తే, నేను భయపడను."