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

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. మినహాయింపులు చుట్టడం

తనిఖీ చేయబడిన మినహాయింపులు సిద్ధాంతంలో చల్లగా అనిపించాయి, కానీ ఆచరణలో చాలా నిరాశగా మారాయి.

మీరు మీ ప్రాజెక్ట్‌లో సూపర్ పాపులర్ పద్ధతిని కలిగి ఉన్నారని అనుకుందాం. ఇది మీ ప్రోగ్రామ్‌లోని వందలాది ప్రదేశాల నుండి పిలువబడుతుంది. మరియు మీరు దీనికి కొత్త తనిఖీ చేయబడిన మినహాయింపును జోడించాలని నిర్ణయించుకుంటారు . మరియు ఈ తనిఖీ చేయబడిన మినహాయింపు నిజంగా ముఖ్యమైనది మరియు చాలా ప్రత్యేకమైనది కావచ్చు , main()అది పట్టుబడితే ఏమి చేయాలో మాత్రమే పద్ధతికి తెలుసు.

అంటే మీరు మీ సూపర్ పాపులర్ మెథడ్‌ని పిలిచే ప్రతి పద్ధతి యొక్క నిబంధనకు తనిఖీ చేయబడిన మినహాయింపును జోడించాలిthrows . అలాగే throwsఆ పద్ధతులను పిలిచే అన్ని పద్ధతుల యొక్క నిబంధనలో. మరియు ఆ పద్ధతులను పిలిచే పద్ధతులు.

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

ఆపై మీ అన్ని కోడ్‌లు (వందలాది ఫైల్‌లలోని అన్ని మార్పులు) ఇతర ప్రోగ్రామర్లచే సమీక్షించబడాలి. మరియు ఈ సమయంలో మేము ప్రాజెక్ట్‌లో చాలా రక్తపాత మార్పులు ఎందుకు చేసాము అని మనల్ని మనం ప్రశ్నించుకుంటాము? రోజు(లు?) పని, మరియు విరిగిన పరీక్షలు — అన్నీ ఒక తనిఖీ చేయబడిన మినహాయింపును జోడించడం కోసమేనా ?

మరియు వాస్తవానికి, వారసత్వం మరియు పద్ధతిని అధిగమించడానికి సంబంధించిన సమస్యలు ఇప్పటికీ ఉన్నాయి. తనిఖీ చేయబడిన మినహాయింపుల నుండి వచ్చే సమస్యలు ప్రయోజనం కంటే చాలా పెద్దవి. బాటమ్ లైన్ ఏమిటంటే, ఇప్పుడు కొంతమంది వాటిని ఇష్టపడతారు మరియు కొంతమంది వాటిని ఉపయోగిస్తున్నారు.

అయినప్పటికీ ఈ తనిఖీ చేయబడిన మినహాయింపులను కలిగి ఉన్న చాలా కోడ్ (ప్రామాణిక జావా లైబ్రరీ కోడ్‌తో సహా) ఇప్పటికీ ఉంది . వారితో ఏమి చేయాలి? మేము వాటిని విస్మరించలేము మరియు వాటిని ఎలా నిర్వహించాలో మాకు తెలియదు.

జావా ప్రోగ్రామర్లు తనిఖీ చేయబడిన మినహాయింపులను ర్యాప్ చేయాలని ప్రతిపాదించారు RuntimeException. మరో మాటలో చెప్పాలంటే, తనిఖీ చేయబడిన అన్ని మినహాయింపులను పట్టుకుని, ఆపై ఎంపిక చేయని మినహాయింపులను సృష్టించండి (ఉదాహరణకు, RuntimeException) మరియు బదులుగా వాటిని విసిరేయండి. అలా చేయడం ఇలా కనిపిస్తుంది:

try
{
   // Code where a checked exception might occur
}
catch(Exception exp)
{
   throw new RuntimeException(exp);
}

ఇది చాలా అందమైన పరిష్కారం కాదు, కానీ ఇక్కడ నేరపూరితంగా ఏమీ లేదు: మినహాయింపు ఒక లోపల నింపబడింది RuntimeException.

కావాలనుకుంటే, మీరు దానిని అక్కడ నుండి సులభంగా తిరిగి పొందవచ్చు. ఉదాహరణ:

try
{
   // Code where we wrap the checked exception
   // in a RuntimeException
}
catch(RuntimeException e)
{
   Throwable cause = e.getCause();
   if (cause instanceof Exception)
   {
      Exception exp = (Exception) cause;
      // Exception handling code goes here
   }
}

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

ప్రోగ్రామర్లు నిజంగా నకిలీ కోడ్‌ని అసహ్యించుకుంటారు. వారు సంబంధిత అభివృద్ధి సూత్రంతో కూడా ముందుకు వచ్చారు: మీరే పునరావృతం చేయవద్దు (DRY) . కానీ మినహాయింపులను నిర్వహించేటప్పుడు, ఒకే కోడ్‌తో ఒక 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.

5. కస్టమ్ మినహాయింపులు

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

class ClassName extends RuntimeException
{
}

మీరు OOP, వారసత్వం, కన్‌స్ట్రక్టర్‌లు మరియు మెథడ్ ఓవర్‌రైడింగ్ నేర్చుకున్నప్పుడు మేము వివరాలను చర్చిస్తాము.

అయినప్పటికీ, మీరు ఇలాంటి సాధారణ తరగతిని మాత్రమే కలిగి ఉన్నప్పటికీ (పూర్తిగా కోడ్ లేకుండా), మీరు దాని ఆధారంగా మినహాయింపులను విసరవచ్చు:

class Solution
{
   public static void main(String[] args)
   {
      throw new MyException();
   }
}

class MyException extends RuntimeException
{
}

జావా మల్టీథ్రెడింగ్ అన్వేషణలో , మేము మా స్వంత కస్టమ్ మినహాయింపులతో పని చేయడానికి లోతైన డైవ్ చేస్తాము.