మల్టీ-క్యాచ్ ఎలా పనిచేస్తుంది

"మరికొన్ని ఆసక్తికరమైన పాఠాలు. ఓహ్, ఐ లవ్ టీచింగ్!"

"మల్టిపుల్ క్యాచ్ బ్లాక్‌లు ఎలా పని చేస్తాయో నేను మీకు చెప్పాలనుకుంటున్నాను . ఇది చాలా సులభం: ట్రై బ్లాక్‌లో మినహాయింపులు సంభవించినప్పుడు, ఎగ్జిక్యూషన్ మొదటి క్యాచ్ బ్లాక్‌కి తరలించబడుతుంది."

"క్యాచ్ బ్లాక్ యొక్క కుండలీకరణాల్లో సూచించబడిన రకం విసిరిన మినహాయింపు రకంతో సరిపోలితే, ఆ బ్లాక్ లోపల అమలు ప్రారంభమవుతుంది. లేకుంటే, మేము తదుపరి క్యాచ్ బ్లాక్‌కి వెళ్తాము, అక్కడ అదే తనిఖీ చేయబడుతుంది."

"మేము క్యాచ్ బ్లాక్‌లు అయిపోతే మరియు మినహాయింపు క్యాచ్ చేయబడకపోతే, అది తిరిగి విసిరివేయబడుతుంది మరియు ప్రస్తుత పద్ధతి అసాధారణంగా ముగుస్తుంది."

"నేను చూస్తున్నాను. మినహాయింపు రకంతో సరిపోయే క్యాచ్ బ్లాక్ అమలు చేయబడినది."

"అవును, నిజమే. అయితే, వాస్తవానికి ఇది కొంచెం క్లిష్టంగా ఉంటుంది. తరగతులు ఇతర తరగతులను వారసత్వంగా పొందగలవు. ఒక ఆవు తరగతి జంతు తరగతిని వారసత్వంగా పొందినట్లయితే, ఆవు వస్తువు కేవలం ఆవు వేరియబుల్ ద్వారా మాత్రమే కాకుండా, యానిమల్ వేరియబుల్ ద్వారా కూడా సూచించబడవచ్చు. "

"మరి?"

"అన్ని మినహాయింపులు మినహాయింపు లేదా రన్‌టైమ్ ఎక్సెప్షన్‌ను వారసత్వంగా పొందుతాయి కాబట్టి (ఇది మినహాయింపును కూడా వారసత్వంగా పొందుతుంది), వాటిని ఇప్పటికీ 'క్యాచ్ ( ఎక్సెప్షన్ ఇ)' లేదా ' క్చ్ (రన్‌టైమ్ ఎక్సెప్షన్ ఇ) ' ఉపయోగించి క్యాచ్ చేయవచ్చు ."

"మరి?"

"మేము రెండు తీర్మానాలు చేయవచ్చు. ముందుగా, మీరు ఏదైనా మినహాయింపును పట్టుకోవడానికి 'క్యాచ్ (మినహాయింపు ఇ)'ని ఉపయోగించవచ్చు. రెండవది, క్యాచ్ బ్లాక్‌ల క్రమం ముఖ్యమైనది. "

"ఇవి కొన్ని ఉదాహరణలు:"

" ArithmeticExceptionమనం 0 ద్వారా విభజించిన తర్వాత సంభవించేది రెండవ క్యాచ్ బ్లాక్‌లో క్యాచ్ చేయబడుతుంది."

try
{
    System.out.println("Before calling method1.");
    int a = 1 / 0;
    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.");
}

"దిగువ ఉదాహరణలో, ArithmeticExceptionమొదటి క్యాచ్ బ్లాక్‌లో క్యాచ్ చేయబడుతుంది, ఎందుకంటే అన్ని మినహాయింపులు మినహాయింపును వారసత్వంగా పొందుతాయి, అంటే Exceptionఅన్ని మినహాయింపులను కవర్ చేస్తుంది. "

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

"దిగువ ఉదాహరణలో, ArithmeticExceptionక్యాచ్ చేయబడదు. ఇది కాలింగ్ పద్ధతికి తిరిగి పంపబడుతుంది."

try
{
    System.out.println("Before calling method1.");
    int a = 1/0;
    System.out.println("After calling method1. This will never be shown.");
}
catch (NullPointerException e)
{
    System.out.println("Null reference. Exception has been caught.");
}

"ఇది విషయాలను కొంచెం క్లియర్ చేసింది. ఈ మినహాయింపులు సులభమైన అంశం కాదు."

"అది అలానే అనిపిస్తుంది. నిజానికి అవి జావాలో చాలా సులభమైన విషయాలలో ఒకటి."

"దాని గురించి సంతోషించాలో లేదా బాధపడాలో నాకు తెలియదు ..."