మినహాయింపుల రకాలు

1. మినహాయింపుల రకాలు

అన్ని మినహాయింపులు 4 రకాలుగా విభజించబడ్డాయి, వాస్తవానికి అవి ఒకదానికొకటి వారసత్వంగా వచ్చే తరగతులు.

Throwableతరగతి

అన్ని మినహాయింపులకు బేస్ క్లాస్ క్లాస్ Throwable. తరగతి Throwableప్రస్తుత కాల్ స్టాక్‌ను (ప్రస్తుత పద్ధతి యొక్క స్టాక్ ట్రేస్) శ్రేణికి వ్రాసే కోడ్‌ను కలిగి ఉంటుంది. స్టాక్ ట్రేస్ అంటే ఏమిటో మనం కొంచెం తర్వాత నేర్చుకుంటాము.

త్రో ఆపరేటర్ తరగతి నుండి వచ్చిన వస్తువును మాత్రమే అంగీకరించగలరు Throwable. మరియు మీరు సిద్ధాంతపరంగా కోడ్‌ని వ్రాయగలిగినప్పటికీ throw new Throwable();, సాధారణంగా ఎవరూ దీన్ని చేయరు. Throwableఅన్ని మినహాయింపులకు ఒకే పేరెంట్ క్లాస్‌ను కలిగి ఉండటమే తరగతి యొక్క ముఖ్య ఉద్దేశ్యం .

Errorతరగతి

తదుపరి మినహాయింపు తరగతి తరగతి Error, ఇది నేరుగా Throwableతరగతిని వారసత్వంగా పొందుతుంది. తీవ్రమైన సమస్యలు సంభవించినప్పుడు జావా యంత్రం తరగతి వస్తువులను Error(మరియు దాని వారసులు) సృష్టిస్తుంది . ఉదాహరణకు, హార్డ్‌వేర్ పనిచేయకపోవడం, తగినంత మెమరీ లేకపోవడం మొదలైనవి.

సాధారణంగా, ప్రోగ్రామర్‌గా, ప్రోగ్రామ్‌లో అటువంటి లోపం (ఏ రకంగా విసిరివేయబడాలి) సంభవించిన సందర్భంలో మీరు ఏమీ చేయలేరు : ఈ లోపాలు చాలా తీవ్రమైనవి. Errorప్రోగ్రామ్ క్రాష్ అవుతుందని వినియోగదారుకు తెలియజేయడం మరియు/లేదా లోపం గురించి తెలిసిన మొత్తం సమాచారాన్ని ప్రోగ్రామ్ లాగ్‌లో వ్రాయడం మాత్రమే మీరు చేయగలిగింది.

Exceptionతరగతి

మరియు Exceptionతరగతులు RuntimeExceptionచాలా పద్ధతుల యొక్క ఆపరేషన్‌లో జరిగే సాధారణ లోపాల కోసం. ప్రతి విసిరిన మినహాయింపు యొక్క లక్ష్యం దానిని సరిగ్గా ఎలా నిర్వహించాలో తెలిసిన బ్లాక్ ద్వారా క్యాచ్ చేయడం .catch

కొన్ని కారణాల వల్ల ఒక పద్ధతి దాని పనిని పూర్తి చేయలేనప్పుడు, తగిన రకం మినహాయింపును విసిరి కాలింగ్ పద్ధతిని వెంటనే తెలియజేయాలి.

మరో మాటలో చెప్పాలంటే, ఒక వేరియబుల్ సమానంగా ఉంటే null, పద్ధతి a త్రో చేస్తుంది NullPointerException. తప్పు వాదనలు పద్ధతికి పంపబడితే, అది ఒక త్రో చేస్తుంది InvalidArgumentException. పద్ధతి అనుకోకుండా సున్నాతో భాగిస్తే, అది ఒక త్రో చేస్తుంది ArithmeticException.

RuntimeExceptionతరగతి

RuntimeExceptionsయొక్క ఉపసమితి Exceptions. RuntimeExceptionఇది సాధారణ మినహాయింపుల ( ) యొక్క తేలికైన సంస్కరణ అని కూడా మేము చెప్పగలము Exception- అటువంటి మినహాయింపులపై తక్కువ అవసరాలు మరియు పరిమితులు విధించబడతాయి

Exceptionమరియు తర్వాత మధ్య వ్యత్యాసాన్ని మీరు నేర్చుకుంటారు RuntimeException.

2. Throws: తనిఖీ చేయబడిన మినహాయింపులు

అన్ని జావా మినహాయింపులు 2 వర్గాలలోకి వస్తాయి: తనిఖీ చేయబడ్డాయి మరియు ఎంపిక చేయబడలేదు .

వారసత్వంగా పొందే RuntimeExceptionలేదా తనిఖీ చేయని మినహాయింపులుగాError పరిగణించబడే అన్ని మినహాయింపులు . మిగతావన్నీ తనిఖీ చేయబడిన మినహాయింపులు .

తనిఖీ చేయబడిన మరియు ఎంపిక చేయని మినహాయింపుల మధ్య ప్రధాన తేడా ఏమిటి ?

తనిఖీ చేయబడిన మినహాయింపులపై అదనపు అవసరాలు విధించబడ్డాయి . స్థూలంగా చెప్పాలంటే, అవి:

అవసరం 1

ఒక పద్ధతి తనిఖీ చేయబడిన మినహాయింపును విసిరినట్లయితే , అది తప్పనిసరిగా దాని సంతకంలో మినహాయింపు రకాన్ని సూచించాలి . ఆ విధంగా, దానిని పిలిచే ప్రతి పద్ధతి దానిలో ఈ "అర్ధవంతమైన మినహాయింపు" సంభవించవచ్చని తెలుసు.

కీవర్డ్ తర్వాత పద్ధతి పారామితుల తర్వాత తనిఖీ చేయబడిన మినహాయింపులను సూచించండి ( పొరపాటున కీవర్డ్‌ని ఉపయోగించవద్దు ). ఇది ఇలా కనిపిస్తుంది:throwsthrow

type method (parameters) throws exception

ఉదాహరణ:

public void calculate(int n) throws Exception
{
   if (n == 0)
      throw new Exception("n is null!");
}

public void calculate(n)
{
   if (n == 0)
      throw new RuntimeException("n is null!");
}

కుడివైపున ఉన్న ఉదాహరణలో, మా కోడ్ ఎంపిక చేయని మినహాయింపును విసురుతుంది - అదనపు చర్య అవసరం లేదు. ఎడమ వైపున ఉన్న ఉదాహరణలో, పద్ధతి తనిఖీ చేయబడిన మినహాయింపును విసురుతుంది, కాబట్టి throwsమినహాయింపు రకంతో పాటు పద్ధతి సంతకానికి కీవర్డ్ జోడించబడుతుంది.

ఒక పద్ధతి బహుళ తనిఖీ చేయబడిన మినహాయింపులను విసిరివేయాలని ఆశించినట్లయితే , అవన్నీ తప్పనిసరిగా throwsకామాలతో వేరు చేయబడిన కీవర్డ్ తర్వాత పేర్కొనబడాలి. ఆర్డర్ ముఖ్యం కాదు. ఉదాహరణ:

public void calculate(int n) throws Exception, IOException
{
   if (n == 0)
      throw new Exception("n is null!");
   if (n == 1)
      throw new IOException("n is 1");
}

అవసరం 2

మీరు దాని సంతకంలో మినహాయింపులను తనిఖీ చేసిన పద్ధతికి కాల్ చేస్తే , అది వాటిని విసిరే వాస్తవాన్ని మీరు విస్మరించలేరు.

catchమీరు ప్రతిదానికి బ్లాక్‌లను జోడించడం ద్వారా లేదా మీ పద్ధతికి సంబంధించిన నిబంధనకు వాటిని జోడించడంthrows ద్వారా అటువంటి మినహాయింపులన్నింటినీ తప్పనిసరిగా పట్టుకోవాలి .

"ఈ మినహాయింపులు చాలా ముఖ్యమైనవి కాబట్టి మనం వాటిని పట్టుకోవాలి. మరియు వాటిని ఎలా నిర్వహించాలో మనకు తెలియకపోతే, మా పద్ధతిని పిలిచే ఎవరికైనా అటువంటి మినహాయింపులు సంభవించవచ్చని తెలియజేయాలి.

ఉదాహరణ:

మానవుల జనాభాతో కూడిన ప్రపంచాన్ని సృష్టించడానికి మేము ఒక పద్ధతిని వ్రాస్తున్నామని ఊహించుకోండి. వ్యక్తుల ప్రారంభ సంఖ్య వాదనగా ఆమోదించబడింది. కాబట్టి చాలా తక్కువ మంది వ్యక్తులు ఉంటే మేము మినహాయింపులను జోడించాలి.

public void createWorld(int n) throws EmptyWorldException, LonelyWorldException
{
   if (n == 0)
      throw new EmptyWorldException("There are no people!");
   if (n == 1)
      throw new LonelyWorldException ("There aren't enough people!");
   System.out.println("A wonderful world was created. Population: " + n);
}

ఈ పద్ధతి కాల్‌ను 3 మార్గాల్లో నిర్వహించవచ్చు:

1. ఎలాంటి మినహాయింపులను పొందవద్దు

పరిస్థితిని ఎలా సరిగ్గా నిర్వహించాలో పద్ధతికి తెలియనప్పుడు ఇది చాలా తరచుగా జరుగుతుంది.

public void createPopulatedWorld(int population)
throws EmptyWorldException, LonelyWorldException
{
   createWorld(population);
}

2. కొన్ని మినహాయింపులను పట్టుకోండి

మేము నిర్వహించగల లోపాలను మేము నిర్వహిస్తాము. కానీ మనకు అర్థం కాని వాటిని, మేము వాటిని కాల్ పద్ధతికి విసిరివేస్తాము. దీన్ని చేయడానికి, మేము వారి పేరును త్రోస్ నిబంధనకు జోడించాలి:

public void createNonEmptyWorld(int population)
throws EmptyWorldException
{
   try
   {
      createWorld(population);
   }
   catch (LonelyWorldException e)
   {
      e.printStackTrace();
   }
}

3. అన్ని మినహాయింపులను క్యాచ్ చేయండి

పద్ధతి కాలింగ్ పద్ధతికి మినహాయింపులను ఇవ్వకపోతే, కాలింగ్ పద్ధతి ఎల్లప్పుడూ ప్రతిదీ బాగా పనిచేస్తుందని నమ్మకంగా ఉంటుంది. మరియు అది అసాధారణమైన పరిస్థితులను పరిష్కరించడానికి ఎటువంటి చర్య తీసుకోలేకపోతుంది.

public void createAnyWorld(int population)
{
   try
   {
      createWorld(population);
   }
   catch (LonelyWorldException e)
   {
      e.printStackTrace();
   }
   catch (EmptyWorldException e)
   {
      e.printStackTrace();
   }
}

3. బహుళ మినహాయింపులను పొందడం

ప్రోగ్రామర్లు నిజంగా నకిలీ కోడ్‌ని అసహ్యించుకుంటారు. వారు సంబంధిత అభివృద్ధి సూత్రంతో కూడా ముందుకు వచ్చారు - డ్రై : మీరే పునరావృతం చేయవద్దు. కానీ మినహాయింపులను నిర్వహించేటప్పుడు, ఒకే కోడ్‌తో ఒక tryబ్లాక్‌ని అనేక బ్లాక్‌లు అనుసరించే సందర్భాలు తరచుగా ఉంటాయి.catch

catchలేదా ఒకే కోడ్‌తో 3 బ్లాక్‌లు మరియు ఇతర ఒకే కోడ్‌తో మరో 2 బ్లాక్‌లు ఉండవచ్చు catch. మీ ప్రాజెక్ట్ మినహాయింపులను బాధ్యతాయుతంగా నిర్వహించినప్పుడు ఇది ఒక ప్రామాణిక పరిస్థితి .

వెర్షన్ 7తో ప్రారంభించి, జావా భాషలో ఒకే బ్లాక్‌లో అనేక రకాల మినహాయింపులను పేర్కొనే సామర్థ్యాన్ని జోడించారు catch. ఇది సుమారుగా ఇలా కనిపిస్తుంది:

try
{
   // Code where an exception might occur
}
catch (ExceptionType1 | ExceptionType2 | ExceptionType3 name)
{
   // Exception handling code
}

catchమీకు కావలసినన్ని బ్లాక్‌లను మీరు కలిగి ఉండవచ్చు . catchఅయినప్పటికీ, ఒకదానికొకటి వారసత్వంగా వచ్చే మినహాయింపులను ఒకే బ్లాక్ పేర్కొనలేదు. మరో మాటలో చెప్పాలంటే, మీరు క్యాచ్ ( Exception| RuntimeExceptionఇ) అని వ్రాయలేరు ఎందుకంటే RuntimeExceptionతరగతి వారసత్వంగా Exception.