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

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. மடக்கு விதிவிலக்குகள்

சரிபார்க்கப்பட்ட விதிவிலக்குகள் கோட்பாட்டில் அருமையாகத் தோன்றின, ஆனால் நடைமுறையில் பெரும் ஏமாற்றமாக மாறியது.

உங்கள் திட்டத்தில் மிகவும் பிரபலமான முறை உள்ளது என்று வைத்துக்கொள்வோம். இது உங்கள் திட்டத்தில் நூற்றுக்கணக்கான இடங்களிலிருந்து அழைக்கப்படுகிறது. மேலும் அதில் ஒரு புதிய சரிபார்க்கப்பட்ட விதிவிலக்கை சேர்க்க முடிவு செய்கிறீர்கள் . இந்த சரிபார்க்கப்பட்ட விதிவிலக்கு மிகவும் முக்கியமானது மற்றும் மிகவும் சிறப்பு வாய்ந்ததாக இருக்கலாம் , 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) . ஆனால் விதிவிலக்குகளைக் கையாளும் போது, ​​ஒரு தொகுதியைத் தொடர்ந்து ஒரே குறியீட்டைக் கொண்ட பல தொகுதிகள் அடிக்கடி வரும் .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.

5. தனிப்பயன் விதிவிலக்குகள்

நீங்கள் எப்போதும் உங்கள் சொந்த விதிவிலக்கு வகுப்பை உருவாக்கலாம். வகுப்பை மரபுரிமையாகக் கொண்ட ஒரு வகுப்பை உருவாக்குகிறீர்கள் RuntimeException. இது இப்படி இருக்கும்:

class ClassName extends RuntimeException
{
}

OOP, பரம்பரை, கன்ஸ்ட்ரக்டர்கள் மற்றும் முறை மேலெழுதுதல் ஆகியவற்றை நீங்கள் கற்றுக் கொள்ளும்போது விவரங்களைப் பற்றி விவாதிப்போம்.

இருப்பினும், உங்களிடம் இது போன்ற ஒரு எளிய வகுப்பு மட்டுமே இருந்தாலும் (முற்றிலும் குறியீடு இல்லாமல்), அதன் அடிப்படையில் நீங்கள் விதிவிலக்குகளை எறியலாம்:

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

class MyException extends RuntimeException
{
}

ஜாவா மல்டித்ரெடிங் தேடலில் , எங்கள் சொந்த தனிப்பயன் விதிவிலக்குகளுடன் வேலை செய்வதில் ஆழ்ந்து மூழ்குவோம்.