మినహాయింపులు విసరడం

1. throwఆపరేటర్

మినహాయింపు ఒక బ్లాక్ ద్వారా క్యాచ్ చేయబడినప్పుడు catchమరియు అది జావా మెషీన్‌కు విసిరే వరకు, అది వారసత్వంగా పొందే వస్తువు మాత్రమే Exception(లేదా బదులుగా, Throwable). మినహాయింపు వస్తువు స్వయంగా ఏ మాయా లక్షణాలను కలిగి ఉండదు.

మినహాయింపులు ఎలా పని చేస్తాయనే అన్ని తర్కం జావా మెషీన్‌కు మినహాయింపు ఇచ్చినప్పుడు ప్రవర్తించే ప్రత్యేక మార్గం.

మీరు ఎప్పుడైనా జావా మెషీన్‌కు క్యాచ్ చేయబడిన మినహాయింపును తిరిగి వేయవచ్చు. దీన్ని చేయడానికి, మీరు ఆపరేటర్ని ఉపయోగించాలి throw:

throw exception;

ఉదాహరణ:

try
{
   int d = 2/0;
}
catch(Exception except)
{
   System.out.println("Caught the exception");
   throw except;
}

Caught the exception

ఈ కోడ్‌లో, మేము మినహాయింపును పొందాము, స్క్రీన్‌పై దాని గురించి సందేశాన్ని ప్రదర్శించాము, ఆపై దాన్ని మళ్లీ విసిరాము.

catchఅదే బ్లాక్‌లోని ఇతర బ్లాక్‌ల ద్వారా తిరిగి విసిరిన మినహాయింపు క్యాచ్ చేయబడదు try.

2. మీ మినహాయింపులు

మార్గం ద్వారా, మీరు ఒక మినహాయింపు వస్తువును మీరే సృష్టించవచ్చు: ఇది కేవలం ఒక వస్తువు దాని రకం Exceptionలేదా దానిని వారసత్వంగా పొందే తరగతి. మరియు దానిని విసిరేయండి.

ఇది ధ్వనించే దానికంటే సులభం. ఉదాహరణ:

try
{
   throw new RuntimeException();
}
catch(Exception except)
{
   System.out.println("Caught the exception");
   throw except;
}

Caught the exception

ఎగువ ఉదాహరణలో, మేము కొత్త మినహాయింపు వస్తువును సృష్టించాము, దాని రకం RuntimeExceptionమరియు వెంటనే ఆపరేటర్‌ని ఉపయోగించి దాన్ని విసిరాము throw.

catchRuntimeException వారసత్వంగా పొందుతుంది కాబట్టి ఇది బ్లాక్ ద్వారా వెంటనే క్యాచ్ చేయబడుతుంది Exception. catch (Exception except)తరగతిని వారసత్వంగా పొందే అన్ని తరగతుల మినహాయింపు వస్తువులను కోడ్ క్యాచ్ చేస్తుంది Exception.

3. finallyకీవర్డ్

మరో ముఖ్యమైన అంశం. కొన్నిసార్లు ప్రోగ్రామర్ కోడ్‌లో మినహాయింపు సంభవించిందా అనే దానితో సంబంధం లేకుండా కొంత చర్యను చేయాల్సి ఉంటుంది. ఉదాహరణకు, మనం వ్రాయడం కోసం ఒక ఫైల్‌ను తెరిచామని అనుకుందాం. తెరిచిన ఫైల్ తప్పనిసరిగా కాల్ చేయడం ద్వారా మూసివేయబడాలి close().

try
{
   // Code where an exception might occur
}
catch(ExceptionType name)
{
   // Exception handling code
}
finally
{
   // Code that must executed no matter what happens
}

ఈ తప్పనిసరి చర్యలను నిర్వహించడానికి, మరొక రకమైన బ్లాక్ ( finally) నిర్మాణానికి జోడించబడింది try-catch, తద్వారా try-catch-finallyనిర్మాణాన్ని సృష్టిస్తుంది. ఇది ఇలా కనిపిస్తుంది:

ఉదాహరణ:

FileInputStream source = null;
try
{
   source = new FileInputStream("c:\\note.txt");
   source.read();
}
catch(Exception except)
{
   System.out.println("Caught the exception");
   throw except;
}
finally
{
   if (source != null)
      source.close();
}

finallyబ్లాక్‌లోని కోడ్ ఏదైనా సందర్భంలో, మినహాయింపు ఉన్నదా అనే దానితో సంబంధం లేకుండా అమలు చేయబడుతుంది. మినహాయింపు విసిరినా, పట్టుకోకపోయినా, finallyబ్లాక్ ఇప్పటికీ అమలు అవుతుంది.

మార్గం ద్వారా, మీరు మినహాయింపును పొందకూడదనుకుంటే, కానీ మీకు బ్లాక్ అవసరమైతే finally, నిర్మాణం కోసం సంక్షిప్తలిపి సంజ్ఞామానాన్ని ఉపయోగించండి try-catch-finally: ఒక try-finallyబ్లాక్. ఇది ఇలా కనిపిస్తుంది:

try
{
   // Code where an exception might occur
}
finally
{
   // Code that must executed no matter what happens
}