விதிவிலக்குகளின் வகைகள்

1. விதிவிலக்குகளின் வகைகள்

அனைத்து விதிவிலக்குகளும் 4 வகைகளாகப் பிரிக்கப்பட்டுள்ளன, அவை உண்மையில் ஒருவருக்கொருவர் மரபுரிமையாக இருக்கும் வகுப்புகள்.

Throwableவர்க்கம்

அனைத்து விதிவிலக்குகளுக்கும் அடிப்படை வகுப்பு வகுப்பு Throwable. வகுப்பில் Throwableதற்போதைய அழைப்பு அடுக்கை (தற்போதைய முறையின் ஸ்டேக் ட்ரேஸ்) வரிசைக்கு எழுதும் குறியீடு உள்ளது. ஸ்டாக் ட்ரேஸ் என்றால் என்ன என்பதை சிறிது நேரம் கழித்து அறிந்து கொள்வோம்.

த்ரோ ஆபரேட்டர் வகுப்பில் இருந்து பெறப்படும் ஒரு பொருளை மட்டுமே ஏற்க முடியும் Throwable. நீங்கள் கோட்பாட்டளவில் போன்ற குறியீட்டை எழுத முடியும் என்றாலும் throw new Throwable();, யாரும் பொதுவாக இதைச் செய்வதில்லை. வகுப்பின் முக்கிய நோக்கம் Throwableஅனைத்து விதிவிலக்குகளுக்கும் ஒற்றை பெற்றோர் வகுப்பைக் கொண்டிருக்க வேண்டும்.

Errorவர்க்கம்

அடுத்த விதிவிலக்கு வகுப்பு Errorவர்க்கம் ஆகும், இது வகுப்பை நேரடியாகப் பெறுகிறது Throwable. ஜாவா இயந்திரம் கடுமையான சிக்கல்கள் ஏற்படும் போதுError வகுப்பின் பொருட்களை (மற்றும் அதன் சந்ததியினர்) உருவாக்குகிறது . எடுத்துக்காட்டாக, வன்பொருள் செயலிழப்பு, போதுமான நினைவகம் போன்றவை.

வழக்கமாக, ஒரு புரோகிராமராக, நிரலில் இதுபோன்ற பிழை (எறியப்பட வேண்டிய வகை ) ஏற்பட்டால் நீங்கள் எதுவும் செய்ய முடியாது : இந்த பிழைகள் மிகவும் தீவிரமானவை. Errorநீங்கள் செய்யக்கூடியது, நிரல் செயலிழக்கிறது என்பதை பயனருக்குத் தெரிவிப்பது மற்றும்/அல்லது பிழையைப் பற்றிய அனைத்து அறியப்பட்ட தகவலை நிரல் பதிவில் எழுதுவது மட்டுமே.

Exceptionவர்க்கம்

தி Exceptionமற்றும் RuntimeExceptionவகுப்புகள் பல முறைகளின் செயல்பாட்டில் ஏற்படும் பொதுவான பிழைகள் ஆகும். எறியப்பட்ட ஒவ்வொரு விதிவிலக்கின் குறிக்கோள் , அதை எவ்வாறு சரியாகக் கையாள்வது என்பதை அறிந்த ஒரு தொகுதியால் பிடிக்கப்பட வேண்டும் .catch

சில காரணங்களால் ஒரு முறை அதன் வேலையை முடிக்க முடியாமல் போனால், அது பொருத்தமான வகையின் விதிவிலக்கை எறிந்து அழைப்பு முறையை உடனடியாக அறிவிக்க வேண்டும்.

வேறு வார்த்தைகளில் கூறுவதானால், ஒரு மாறி சமமாக இருந்தால் null, முறை ஒரு 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. பல விதிவிலக்குகளைப் பிடிக்கிறது

புரோகிராமர்கள் உண்மையில் நகல் குறியீட்டை வெறுக்கிறார்கள். அவர்கள் ஒரு தொடர்புடைய வளர்ச்சிக் கொள்கையுடன் கூட வந்தனர் - உலர் : உங்களை மீண்டும் செய்ய வேண்டாம். ஆனால் விதிவிலக்குகளைக் கையாளும் போது, ​​ஒரு தொகுதியைத் தொடர்ந்து ஒரே குறியீட்டைக் கொண்ட பல தொகுதிகள் அடிக்கடி வரும் .trycatch

catchஅல்லது ஒரே குறியீட்டைக் கொண்ட 3 தொகுதிகள் மற்றும் catchபிற ஒத்த குறியீட்டைக் கொண்ட மற்றொரு 2 தொகுதிகள் இருக்கலாம் . உங்கள் திட்டம் விதிவிலக்குகளை பொறுப்புடன் கையாளும் போது இது ஒரு நிலையான சூழ்நிலை .

பதிப்பு 7 இல் தொடங்கி, ஜாவா மொழியில் ஒரு தொகுதியில் பல வகையான விதிவிலக்குகளைக் குறிப்பிடும் திறனைச் சேர்த்தது catch. இது தோராயமாக இப்படி தெரிகிறது:

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

catchநீங்கள் எத்தனை தொகுதிகள் வேண்டுமானாலும் வைத்திருக்கலாம் . இருப்பினும், ஒரு catchதொகுதி ஒன்று மற்றொன்றைப் பெறுகின்ற விதிவிலக்குகளைக் குறிப்பிட முடியாது. வேறு வார்த்தைகளில் கூறுவதானால், நீங்கள் கேட்ச் ( Exception| RuntimeExceptionஇ) எழுத முடியாது, ஏனெனில் RuntimeExceptionவர்க்கம் மரபுரிமையாகிறது Exception.