Computer Class 12 GSEB Solutions Chapter 10 જાવામાં અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન

Students frequently turn to Computer Class 12 GSEB Solutions and GSEB Computer Textbook Solutions Class 12 Chapter 10 જાવામાં અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન for practice and self-assessment.

GSEB Computer Textbook Solutions Class 12 Chapter 10 જાવામાં અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન

પ્રશ્ન 1.
કમ્પાઇલેશન વખતની ભૂલ અને અમલ દરમિયાનની ભૂલ વચ્ચે શું તફાવત છે?
ઉત્તરઃ
કમ્પાઇલ કરતી વખતે ઉદ્ભવતી ભૂલો (Compile-time Errors)

• કોઈ પણ પ્રોગ્રામિંગ ભાષાની મૂળ સૂચનાઓ(Source code)ને કમ્પ્યૂટર દ્વારા અમલમાં મૂકી શકાય તેવી સૂચનાઓ- (Object Code) માં રૂપાંતરિત કરવા માટે કમ્પાઇલરનો ઉપયોગ કરવામાં આવે છે. જો પ્રોગ્રામમાં કોઈ જોડણીની ભૂલ (Syntax Error) હશે, તો આપણને કમ્પાઇલેશન કરતી વખતે જ ભૂલ દર્શાવવામાં આવશે અને તેને કારણે આપણે “.class” ફાઈલ બનાવી શકીશું નહીં.
• સામાન્ય રીતે જોડણીની ભૂલો નીચે મુજબની હોય છે :
  1. અલ્પવિરામ ચિહ્ન ‘,’ ન હોવું.
  2. અવ્યાખ્યાયિત ચલનો ઉપયોગ કરવો.
  3. કોઈ ચાવીરૂપ શબ્દ(Key word)ની ખોટી જોડણી.
  4. ઉઘડતા કૌંસની સંખ્યાના પ્રમાણમાં બંધ થતા કૌંસની સંખ્યાનો વધારો કે ઘટાડો.
  5. આદેશના અંતે અર્ધવિરામ ચિહ્ન ‘;’નો અભાવ વગેરે.
     આકૃતિ માં દર્શાવેલ જાવા પ્રોગ્રામમાં અર્ધવિરામ ચિહ્નની કમી છે, જેને કમ્પાઇલ કરતાં આકૃતિ માં દર્શાવ્યા મુજબ કમ્પાઇલ કરતી વખતે ઉદ્ભવતી ભૂલ દર્શાવવામાં આવે છે, જેમાં જે લાઇન નંબર ઉપર ભૂલ હોય તે નંબર પણ દર્શાવવામાં આવે છે.

• પ્રોગ્રામને કમ્પાઇલ કરતી વખતે ઉદ્ભવતી ક્ષતિઓ મોટે ભાગે પ્રોગ્રામરની ભૂલો હોય છે અને તેને જ્યાં સુધી સુધારવામાં ન આવે ત્યાં સુધી તે પ્રોગ્રામને કમ્પાઇલ થવા દેતી નથી.
  નોંધ : કમ્પ્યૂટર વિજ્ઞાનના ક્ષેત્રે, કોઈ પણ આદેશ કે પ્રોગ્રામનો સફળતાપૂર્વક અમલ થયો છે કે નહીં તેનો નિર્દેશ “Exit code” અથવા “Exit status” કરે છે.
  ૦ (શૂન્ય) – આદેશ સફળતાપૂર્વક અમલમાં મુકાયાનો નિર્દેશ કરે છે.
  1 – અમલ કરતી વખતે કોઈક સમસ્યા ઉદ્ભવી છે તેનો નિર્દેશ કરે છે.

પ્રોગ્રામના અમલ દરમિયાન ઉદ્ભવતી ભૂલો (Run-time Errors during execution of program)

• જો પ્રોગ્રામની સૂચનાઓમાં કોઈ જોડણીની ભૂલ નહીં હોય, તો પ્રોગ્રામ સફળતાપૂર્વક કમ્પાઇલ થશે અને આપણને “.class” ફાઈલ મળશે. આમ છતાં, પ્રોગ્રામ આપણી અપેક્ષા મુજબ જ ચાલશે તેવી કોઈ ખાતરી મળતી નથી.
• આકૃતિ માં દર્શાવેલ પ્રોગ્રામ કમ્પાઇલ તો સફળતાપૂર્વક થશે પણ અમલ કરતી વખતે અસામાન્ય સંજોગોમાં અટકી જશે.
• અહીં પ્રોગ્રામમાં “citylist[ ]” નામનો ઍરે બનાવ્યો છે, જે ચાર જુદાં જુદાં શહેરોનાં નામ સૂચવશે. આ પ્રોગ્રામમાં આપેલ આદેશ System.out.println(citylist[s]); ઍરેના પાંચ ઘટકો દર્શાવવાનો પ્રયત્ન કરે છે. જ્યારે ઍરેમાં ખરેખર ચાર જ ઘટકો છે. આથી અહીં અપવાદરૂપ પરિસ્થિતિ ઉદ્ભવે છે. આ પ્રોગ્રામના અમલનું પરિણામ આકૃતિ માં દર્શાવેલ છે.

• અહીં આપણે જોઈ શકીએ છીએ કે પ્રોગ્રામનો અમલ ઉપર દર્શાવેલ આદેશ પરથી અણધારી રીતે અંત પામે છે અને પરિણામમાં એક કારણદર્શક સંદેશ “ArrayIndexOutOfBoundsException” દર્શાવે છે, જે પ્રોગ્રામના અમલ દરમિયાન ઉદ્ભવેલ અપવાદનો નિર્દેશ કરે છે.
• જાવામાં દરેક પ્રકારના અપવાદ માટે સંબંધિત ઍક્સેપ્શન ક્લાસ (Exception Class) ઉપલબ્ધ છે.
• java.lang અને java.io પૅકેજ વિવિધ અપવાદો સાથે કામ કરતા વર્ગોનો પદાનુક્રમ ધરાવે છે. તેમાંના કેટલાક અપવાદોની યાદી કોષ્ટક 1માં દર્શાવેલ છે.

કોષ્ટક 1 : બહોળા પ્રમાણમાં જોવા મળતા કેટલાક અપવાદોની યાદી

ઍક્સેપ્શન ક્લાસ (Exception Class)	અપવાદ માટેનું કારણ (Condition Resulting in Exception)	ઉદાહરણ (Example)
ArrayIndexOutOfBounds Exception	ઍરેના એલિમેન્ટ તરીકે ઍરેની મર્યાદાની બહારની હોય તેવી કિંમતનો ઉપયોગ.	int a[ ]=new int[4]; a[13] = 99;
ArithmeticException	કોઈ પણ સંખ્યાને શૂન્ય વડે ભાગવાનો પ્રયત્ન.	int a=50/0;
FileNotFoundException	અસ્તિત્વમાં ન હોય તેવી ફાઈલનો ઉપયોગ કરવાનો પ્રયત્ન.
NullPointerException	જ્યાં કોઈ ઑબ્જેક્ટ આવશ્યક હોય તેવા કિસ્સામાં ખાલી કિંમત(Null)નો ઉપયોગ કરવાનો પ્રયત્ન.	String s=null; System.out.println(s. length());
NumberFormatException	કોઈ શબ્દમાળા(String)ને સાંખ્યિક રૂપમાં ફેરવવા માટેનો પ્રયત્ન.	String s=“xyz”; int i=Integer.parseInt(s);
PrinterIOException	મુદ્રણ સમયે થતી ઉદ્ભવેલ ઇનપુટ આઉટપુટ ભૂલ (I/O error)

• આકૃતિ માં અમલ દરમિયાન અપવાદ સર્જતો એક વધુ પ્રોગ્રામ દર્શાવેલ છે.

અહીં આ પ્રોગ્રામમાં આપેલ આદેશ answer = numerator/denominator; એક પૂર્ણાંક સંખ્યાને શૂન્ય વડે ભાગવાનો પ્રયત્ન કરે છે, જેથી પરિણામ અનંતતામાં પરિણમે છે અને ગાણિતિક અપવાદ સર્જાતા આકૃતિ માં દર્શાવ્યા મુજબ અનપેક્ષિત પરિણામ આપશે, જેથી તરત જ પ્રોગ્રામનો અંત આવશે.

પ્રશ્ન 2.
અપવાદ એટલે શું? જાવામાં મળતા કેટલાક અપવાદનાં ઉદાહરણ આપો.
ઉત્તરઃ
અપવાદરૂપ પરિસ્થિતિ પરિચય (Introduction to Exception)

• અપવાદ એ પ્રોગ્રામના અમલ દરમિયાન ઉદ્ભવતી સમસ્યાનો સંકેત છે, જે મોટે ભાગે ભૂલસંદેશ દર્શાવે છે.
• સામાન્ય રીતે કમ્પાઇલ કરેલો પ્રોગ્રામ ક્ષતિ રહિત હોય છે અને તેથી તેનો સફળતાપૂર્વક અમલ થઈ શકે છે. પરંતુ અમુક કિસ્સામાં એવું પણ બને કે આવો ક્ષતિ રહિત પ્રોગ્રામ અમલ દરમિયાન અધવચ્ચે અટકી જાય, જેને અપવાદરૂપ પરિસ્થિતિ કહે છે.
• અપવાદરૂપ પરિસ્થિતિનાં ઉદાહરણ : જો આપણે એવો પ્રોગ્રામ લખ્યો હોય કે જે કોઈ ચોક્કસ વેબ સાઇટ સાથે જોડાણ કરીને વેબ પેજને ડાઉનલોડ કરે, તો સામાન્ય સંજોગોમાં પ્રોગ્રામ અપેક્ષા મુજબ ચાલશે. પરંતુ ધારો કે, આ પ્રોગ્રામ એવા કમ્પ્યૂટરમાં ચલાવવામાં આવે કે જેને ઇન્ટરનેટ સાથે જોડાણ જ ન હોય, તો પ્રોગ્રામ અનપેક્ષિત પરિણામો આપે તેવું બને. આવી પરિસ્થિતિને અપવાદરૂપ પરિસ્થિતિ કહે છે.
• અપવાદરૂપ પરિસ્થિતિઓને પરિણામે પ્રોગ્રામ અપેક્ષિત ધોરણો અનુસાર ચાલતો નથી અને કદાચ અધવચ્ચેથી જ અટકી શકે છે.
• અપવાદનું નિયમન એ એવી આગોતરી વ્યવસ્થા છે કે જે, જાણે કે કોઈ સમસ્યા સર્જાઈ જ નથી તેમ માનીને પ્રોગ્રામનો અમલ ચાલુ જ રાખવા દે છે. અથવા પ્રોગ્રામનો અનિયંત્રિત રીતે અણધાર્યો અંત લાવતા પહેલા તે ઉપયોગકર્તાને જાણ કરે છે.

પ્રશ્ન 3.
જાવામાં અપવાદોનું વ્યવસ્થાપન કેવી રીતે કરવામાં આવે છે?
ઉત્તર:
અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન (Handling Exception)

• અપવાદ એટલે પ્રોગ્રામમાં રહેલી ભૂલ અથવા ક્ષતિ કે જે કમ્પાઇલેશનમાં દર્શાવાતી નથી. અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન એટલે આવી ભૂલ અથવા ક્ષતિઓનું વ્યવસ્થાપન કરવાની વસ્તુલક્ષી (Object-oriented) યુક્તિ.
• અપવાદરૂપ પરિસ્થિતિઓનું વ્યવસ્થાપન કરતી વખતે નીચે દર્શાવેલ બે બાબતોનું ધ્યાન રાખવામાં આવે છે :
  1. પ્રોગ્રામનો અણધારી રીતે અંત ન આવી જાય.
  2. પ્રોગ્રામ અનપેક્ષિત પરિણામ ન આપે.
• અપવાદરૂપ પરિસ્થિતિના વ્યવસ્થાપન માટેનો પ્રોગ્રામ (Exception Handler) લખવા માટે જાવા try, catch અને finally જેવા કી-વર્ડનો ઉપયોગ કરે છે. આ કી-વર્ડ, જ્યારે અપવાદ ઉપસ્થિત થાય ત્યારે ઉપયોગમાં લેવાય છે અને તે વિધાનોના સમૂહને રજૂ કરે છે.
• કોષ્ટક 2માં try, catch અને finally જેવા ચાવીરૂપ શબ્દોની લાક્ષણિકતા દર્શાવેલ છે :

કોષ્ટક 2 : ચાવીરૂપ શબ્દોની લાક્ષણિકતા

ચાવીરૂપ શબ્દો	લાક્ષણિકતા
try	આ વિભાગમાં એવી સૂચનાઓનો સમાવેશ થાય છે કે જે, એક કે વધુ અપવાદોનો ઉદ્ભવ થવા દે છે.
catch	આ વિભાગમાં એવી સૂચનાઓ હોય છે કે જે, સંબંધિત try વિભાગમાં સર્જાય તેવા ચોક્કસ પ્રકારના અપવાદોની સંભાળ લેવા માટે લખવામાં આવી હોય છે.
finally	આ વિભાગનો અમલ હંમેશાં પ્રોગ્રામનો અંત આવે તે પહેલા કરવામાં આવે છે. પછી ભલે try વિભાગમાં કોઈ અપવાદો સર્જાયા હોય કે ન સર્જાયા હોય.

પ્રશ્ન 4.
try, catch અને finally વિભાગની ઉપયોગિતા શું છે?
ઉત્તર :
try વિભાગ (The try Block)

• try વિભાગમાં એવાં વિધાનો લખવામાં આવે છે કે આપણે જે અપવાદની દેખરેખ રાખવા ઇચ્છીએ છીએ. તે માટેની જરૂરી સૂચનાઓ છે. તેમને છડિયા કૌંસમાં સમાવિષ્ટ કરવામાં આવે છે.
• try વિભાગ એક કે તેથી વધુ અપવાદો ઊભા કરી શકે છે.
• try વિભાગની વાક્યરચના (Syntax) :

try
{
//set of statement that may generate one or more exceptions.
}

• આકૃતિ માં દર્શાવેલ સૂચનાઓનો જ્યારે અમલ કરવામાં આવશે, ત્યારે તેમાં અપવાદના વ્યવસ્થાપન(Exception Handler)ની વ્યવસ્થા ન હોવાને કારણે પ્રોગ્રામનો અંત લાવશે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામને કમ્પાઇલ કરવાનો પ્રયત્ન કરવામાં આવશે, તો તે કમ્પાઇલેશન વખતે ભૂલ દર્શાવશે. કારણ કે, try બ્લૉક પછી catch વિભાગ અથવા finally વિભાગ હોવા જરૂરી છે. કમ્પાઇલેશન વખતે દર્શાવાતી ભૂલ આકૃતિ માં દર્શાવેલ છે.

catch વિભાગ (The catch Block)

• catch વિભાગ હંમેશાં try વિભાગની તરત પાછળ હોવો જોઈએ.
• try વિભાગમાં સર્જાયેલ અપવાદના વ્યવસ્થાપન કરવા માટે જરૂરી સૂચનાઓ આ વિભાગમાં લખવામાં આવે છે.
• catch વિભાગ અપવાદનું વ્યવસ્થાપન કરનારો વિભાગ હોવાથી જાવામાં તેને ‘ઍક્સેપ્શન સૅન્ડલર” (Exception Handler) કહે છે.
• કોઈ એક try વિભાગ માટે એક કે તેથી વધુ catch વિભાગ હોઈ શકે છે.
• catch વિભાગની વાક્યરચના (Syntax) :

try
{
//set of statements that may generate one or more exceptions.
}
catch(Exception_Type Exception_object)
}
//Code to handle exception
}

• catch વિભાગમાં કી-વર્ડ તરીકે catch લખી તેની પાછળ એક પેરામિટર આપવામાં આવે છે. આ વિભાગે કયા પ્રકારના અપવાદ સાથે કામ પાર પાડવાનું છે. તે આ પેરામિટર દ્વારા દર્શાવવામાં આવે છે.
  દા. ત., catch(ArrayIndexOutOfBoundsException eobj)
  અહીં, ArrayIndexOutOfBoundException એ પેરામિટર છે અને તે દર્શાવે છે કે કયા પ્રકારના અપવાદ સાથે કામ પાર પાડવાનું છે.
• આકૃતિ માં try-catch વિભાગની રચના દર્શાવવામાં આવી છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં ફક્ત try વિભાગ હતો. તેથી તેમાં કમ્પાઇલેશન વખતે ભૂલ દર્શાવાતી હતી.
  હવે આપણે તે જ પ્રોગ્રામમાં catch વિભાગ ઉમેરીએ. (જુઓ આકૃતિ.)

• આકૃતિ માં દર્શાવેલ સૂચનાઓ સફળતાપૂર્વક કમ્પાઇલ થશે અને તેનો અમલ પણ થશે. અહીં લખેલ catch વિભાગ ArrayIndexOutOfBoundsException ઉદ્ભવે છે, ત્યારે આ અપવાદનું વ્યવસ્થાપન કરે છે અને અનપેક્ષિત રીતે પ્રોગ્રામનો અંત આવવા દેતો નથી.
• catch વિભાગ “eobj” ઑબ્જેક્ટનો નિર્દેશ ધરાવે છે, જેને try વિભાગ દ્વારા સર્જન કરીને મોકલવામાં આવેલ છે.
• આકૃતિ માં આ પ્રોગ્રામનું પરિણામ દર્શાવેલ છે.

એક કરતાં વધુ catch વિભાગ (Multiple catch Blocks)

• એક જ પ્રોગ્રામમાં અનેક અપવાદરૂપ પરિસ્થિતિ સર્જાઈ શકે છે. દા. ત., આપણે ચોક્કસ ફાઈલને દૂરસ્થિત કમ્પ્યૂટર પર અપલોડ કરવી છે, તો તે બે સ્પષ્ટ અપવાદો તરફ દોરી જશે :
  1. જો ફાઈલ આપણા કમ્પ્યૂટર પર ઉપલબ્ધ નહીં હોય.
  2. જો આપણું કમ્પ્યૂટર ઇન્ટરનેટ સાથે જોડાણ ધરાવતું ન હોય.
• એક કરતાં વધુ અપવાદોને સંભાળવા માટે અપવાદ સર્જાવાની શક્યતા ધરાવતી સૂચનાઓ try વિભાગમાં જ લખવી જોઈએ. એ સિવાય દરેક પ્રકારના અપવાદને અલગ રીતે સંભાળવા માટે એક કરતાં વધુ catch વિભાગ હોઈ શકે.
• try વિભાગ જો વિવિધ પ્રકારના અનેક અપવાદો થ્રો (Throw) કરે, તો આપણે જુદા જુદા અપવાદોનું વ્યવસ્થાપન કરી શકે તેવા અનેક catch વિભાગ લખી શકીએ. આ વ્યવસ્થા પ્રોગ્રામરને દરેક પ્રકારના અપવાદ માટે અલગ તર્ક (Logic) લખવા મદદરૂપ થાય છે.
• આકૃતિ અનેક catch વિભાગનો ઉપયોગ દર્શાવે છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં એકથી વધુ catch વિભાગનો ઉપયોગ કરવામાં આવેલ છે. અહીં, try વિભાગની અંદર બે જુદા જ પ્રકારના અપવાદ ઊભા થાય છે :
  1. ArrayIndexOutOfBoundsException – આ અપવાદને પ્રથમ catch વિભાગ દ્વારા પકડી લેવામાં આવશે. અને
  2. ArithmaticException પ્રકારનો અપવાદ બીજા catch વિભાગ દ્વારા પકડી પાડવામાં આવશે.

• આકૃતિ માં દર્શાવેલ છેલ્લો catch વિભાગ કોઈ પણ પ્રકારના અપવાદનું વ્યવસ્થાપન કરી શકે છે. તે એક ‘ડિફૉલ્ટ’ (Default) catch વિભાગ છે.
• જ્યારે અનેક catch વિભાગ હોય ત્યારે ડિફૉલ્ટ catch વિભાગને છેલ્લા વિભાગ તરીકે રાખવો પડે.
• એક કરતાં વધુ try વિભાગને એકની અંદર બીજો, બીજાની અંદર ત્રીજો એમ નેસ્ટિંગ કરીને લખી શકાય. પરંતુ દરેક try વિભાગના સંબંધિત catch વિભાગ લખવાની કાળજી લેવી જરૂરી છે.

finally વિભાગ (The finally Block)

• સામાન્ય રીતે finally વિભાગ, try વિભાગનો અમલ કર્યા પછી અંતે clean up કરવા માટે વપરાય છે.
• સંબંધિત try વિભાગની અંદરથી કયા અપવાદો થ્રો કરવામાં આવશે તેની પરવા કર્યા વગર જ્યારે આપણે એ ખાતરી કરવા ઇચ્છીએ છીએ, કે કોઈ ચોક્કસ સૂચનાઓનો અમલ કરવાનો છે, ત્યારે આપણે finally વિભાગ ઉમેરીએ છીએ.
• finally વિભાગનો અમલ ચોક્કસપણે કરવામાં આવે જ છે.
• પ્રોગ્રામની પૂર્ણતા સમયે જો ફાઈલ બંધ કરવી જરૂરી હોય અથવા કોઈ અગત્યનું સંસાધન મુક્ત કરવાનું હોય ત્યારે finally વિભાગ બહોળા પ્રમાણમાં ઉપયોગમાં લેવાય છે.
• finally વિભાગની વાક્યરચના (Syntax) :

finally
{
//clean-up code to be executed last
//statements within this block always get
//executed even though if run-time errors
//terminate the program abruptly
}

• દરેક try વિભાગની પાછળ ઓછામાં ઓછો એક વિભાગ તો હોવો જ જોઈએ, જે catch વિભાગ હોય અથવા finally વિભાગ હોય.
• આકૃતિ finally વિભાગનો ઉપયોગ કરવાનું ઉદાહરણ દર્શાવે છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં એક પણ catch વિભાગ ન હોવાને લીધે અપવાદ ઉદ્ભવતા જ પ્રોગ્રામનો અધવચ્ચેથી અંત આવી જાય છે, પરંતુ finally વિભાગની ઉપસ્થિતિને લીધે પ્રોગ્રામનો અંત આવે તે પહેલા પ્રોગ્રામ finally વિભાગમાં પડેલાં વિધાનોનો અમલ કરે છે. પ્રોગ્રામનું પરિણામ આકૃતિ માં દર્શાવેલ છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં try વિભાગ, ઘણા બધા catch વિભાગ અને finally વિભાગનો સમાવેશ કરેલ છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામ, try વિભાગમાંથી ઉદ્ભવતા દરેક અપવાદ માટેના સંબંધિત અનેક catch વિભાગ સાથેનો સંપૂર્ણ પ્રોગ્રામ છે. આ પ્રોગ્રામનું પરિણામ આકૃતિ માં દર્શાવેલ છે.

નોંધ : જો finally અને catch વિભાગ સચોટ જગ્યાએ મૂકવામાં નહીં આવ્યા હોય, તો પ્રોગ્રામ કમ્પાઇલ થઈ શકશે નહીં.

પ્રશ્ન 5.
throw અને throws કી-વર્ડની ઉપયોગિતા શું છે?
ઉત્તર:
throw વિધાન (The throw Statement)

• અપવાદના ઑબ્જેક્ટને નિશ્ચિતરૂપે થ્રો કરવા throw કી-વર્ડનો ઉપયોગ કરવામાં આવે છે.
• અત્યાર સુધી આપણે જોયેલા પ્રોગ્રામોમાં JVM (Java Virtual Machine) અપવાદરૂપ ઑબ્જેક્ટ તૈયાર કરીને આપોઆપ થ્રો કરતું હતું. દા. ત., જ્યારે આપણે શૂન્ય વડે ભાગાકાર કરવાની ક્રિયા કરવાનો પ્રયત્ન કર્યો, ત્યારે ArithmaticExceptionનો ઑબ્જેક્ટ બનાવવામાં આવ્યો અને JVM દ્વારા આપોઆપ તેને થ્રો કરવામાં આવ્યો.
• અપવાદનો ઑબ્જેક્ટ બનાવીને નિશ્ચિતરૂપે થ્રો કરવા જાવા વ્યવસ્થા પૂરી પાડે છે. આપણે જે ઑબ્જેક્ટ થ્રો કરીએ, તે java.lang.throwable પ્રકારનો હોવો જ જોઈએ નહીં તો કમ્પાઇલ કરતી વખતે ભૂલ ઉદ્ભવશે.
• અપવાદ ઑબ્જેક્ટને થ્રો કરવા માટેની વાક્યરચના (Syntax) :
  throw exception_object;
• જ્યારે throw વિધાન મળશે ત્યારે, સંબંધિત catch વિભાગની શોધ શરૂ થઈ જશે. આકૃતિ માં લખેલ સૂચનાઓ throw વિધાનનો ઉપયોગ દર્શાવે છે અને તેનું પરિણામ આકૃતિ માં આપવામાં આવ્યું છે.

throws Gulaal (The throws Clause)

• આપણે અત્યાર સુધી ચર્ચેલા પ્રોગ્રામ સાદા હતા કે જેમાં methodનો ઉપયોગ કર્યો ન હતો, પરંતુ જો method કે constructor સમાવેલ હોય અને તેમના દ્વારા જો અપવાદ ઉદ્ભવે તો એવા અપવાદનું વ્યવસ્થાપન કરવા માટે બે રસ્તા છે :
  1. method constructori try-catch વિભાગ લખો કે જે કદાચ અપવાદનું ઉદ્ભવકેન્દ્ર છે.
  2. try વિભાગની અંદર જ method કે constructorને ઇન્વોક કરીને constructor કે methodની અંદરની સૂચના અપવાદ થ્રો કરી શકે તેમ છે, તે જણાવવા method કે constructorને વ્યાખ્યાયિત કરતી વખતે throws ઉપવાક્યનો ઉપયોગ કરી શકાય.
• throws ચાવીરૂપ શબ્દ methodની ઘોષણા કરતી વખતે જ ઉપયોગ કરાય છે.
  methodની ઘોષણા કરતી વખતે throws ઉપવાક્યનો નીચે મુજબ ઉપયોગ કરી શકાય છે :
  method_Modifiers return_type method_Name(Parameters) throws Exception list…

{
...
// body of the method
...
}

• એક method અનેક અપવાદો થ્રો કરી શકે છે. method દ્વારા થ્રો કરી શકાતા દરેક પ્રકારના અપવાદને methodના headerમાં દર્શાવવો જરૂરી છે. દા. ત., methodનું header નીચે મુજબ હોઈ શકે :

perform Division() throws ArithmaticException ArrayIndexOutofBounds Exception
{
...
// body of the method
...
}

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામ ઉપયોગકર્તા નિર્મિત (User defined) methodની ઉપસ્થિતિમાં throws ઉપવાક્યના ઉપયોગનું નિદર્શન કરે છે.

• આકૃતિ માં દર્શાવેલ પ્રોગ્રામમાં આપણે performDivision( ) નામની એક મેથડ લખી છે. આ મેથડમાં ArithmaticExceptionનો ઑબ્જેક્ટ ઉદ્ભવશે. આપણા પ્રોગ્રામની main( ) મેથડમાં performDivision( ) નામની મેથડને કૉલ કરવામાં આવે છે.
• અહીં performDivision( ) મેથડમાં અપવાદ- વ્યવસ્થાપનતંત્ર ન હોવાને લીધે બોલાવનાર મેથડ દ્વારા જ અપવાદ ઝીલવામાં આવશે અને તેથી બોલાવનાર મેથડમાં અપવાદ-વ્યવસ્થાપન માટે Exception Handler હોવું જોઈએ. એ જ રીતે, જાવા ક્લાસના constructorsમાં પણ અપવાદો હોઈ શકે છે.

પ્રશ્ન 6.
જરૂરિયાત અનુસારના અપવાદ તમે કેવી રીતે બનાવશો?
ઉત્તરઃ
જરૂરિયાત મુજબના અપવાદોનું સર્જન (Creating Custom Exceptions)

• જાવા જે-તે વિનિયોગની ખાસ સમસ્યાઓ અનુસાર આપણા પોતાના અપવાદોનું સર્જન કરવાની મંજૂરી આપે છે.
• દા. ત., ધારો કે આપણે ગુણપત્રક તૈયાર કરવાનો પ્રોગ્રામ લખતા હોઈએ, જેમાં ઉપયોગકર્તાને વિવિધ વિષયના ગુણ દાખલ કરવા માટે પૂછવામાં આવતું હોય. દરેક વિષયના ગુણ 0થી 100ની વચ્ચે જ હોવા જોઈએ, ધારો કે ઉપયોગકર્તા કોઈ વિષયના ગુણ તરીકે ઋણ સંખ્યા અથવા 100થી મોટી સંખ્યા દાખલ કરે, તો પ્રોગ્રામે તરત જ અપવાદ ઊભો કરવો જોઈએ.
• આવા પ્રકારના અપવાદ જે-તે વિનિયોગ પૂરતા ખાસ હોય છે. જાવા આવા વિનિયોગ માટે ખાસ એવા અપવાદો માટે આંતરપ્રસ્થાપિત અપવાદ વર્ગ આપતા નથી.
• ઍક્સેપ્શન ક્લાસનો સબક્લાસ બનાવીને આપણે ઉપયાગકર્તા નિર્મિત અપવાદો તૈયાર કરી શકીએ છીએ. આ અપવાદોને throws વિધાનની મદદથી બાહ્ય રીતે થ્રો કરી શકાય છે. જોકે આ અપવાદ ઝીલીને તેને યોગ્ય રીતે પાર પાડવા જરૂરી છે.
• આકૃતિ માં દર્શાવેલ પ્રોગ્રામ ઉપયોગકર્તા તરફથી ઇનપુટ સ્વીકારે છે. કી-બોર્ડ પરથી ઇનપુટ સ્વીકારવા આપણે java.util.Scanner ક્લાસનો ઉપયોગ કર્યો છે.
• Scannar ક્લાસની nextInt( ) મેથડ કૉન્સોલ (Console) પરથી પૂર્ણાંક સંખ્યા વાંચવામાં મદદરૂપ બને છે.

• અહીં આપણે બે વર્ગ પ્રસ્થાપિત કર્યા છે. જરૂરિયાત અનુસાર અપવાદ તૈયાર કરવા એક વધારાના ક્લાસની જરૂરિયાત છે. “InvalidMarksException” વર્ગ java.lang પૅકેજના અપવાદ વર્ગ(Exception Class)ને વિસ્તારે છે.
• તે સિંગલ પેરામિટર કન્સ્ટ્રક્ટર (Constructor) ધરાવે છે, જે ભૂલના પ્રકા૨ને વર્ણવવા માટે શબ્દમાળાને (String) સ્વીકારે છે.
• main( ) મેથડમાં વ્યવસાયિક તર્ક મુજબ સૂચના લખવામાં આવી છે, જે ગુણ નિર્ધારિત મર્યાદાની અંદર જ છે કે કેમ તેની ખાતરી કરે છે.
• જો ગુણ નિર્ધારિત મર્યાદાની અંદર નહીં હોય, તો આપણે “InvalidMarksException” પ્રકારનો ઑબ્જેક્ટ તૈયાર કરીશું અને થ્રો કરીશું.
• આ અપવાદને પાર પાડવા માટે એક catch વિભાગ હોવો જરૂરી છે. જ્યાં સુધી ગુણની યોગ્ય સંખ્યા દાખલ નહીં કરાય, ત્યાં સુધી આ પ્રોગ્રામ આગળ વધશે નહીં.
• આકૃતિ માં દર્શાવેલ પ્રોગ્રામનું પરિણામ આકૃતિ માં દર્શાવેલ છે.

Computer Class 12 GSEB Notes Chapter 10 જાવામાં અપવાદરૂપ પરિસ્થિતિનું વ્યવસ્થાપન

અપવાદના પ્રકારો (Types of Exceptions)

• જાવામાં તમામ પ્રકારની ક્ષતિવાળી પરિસ્થિતિને અપવાદ તરીકે ઓળખવામાં આવે છે.
• પ્રોગ્રામમાં ઉદ્ભવતી ભૂલોને મુખ્યત્વે બે પ્રકારોમાં વિભાજિત કરી શકાય છે :
  1. કમ્પાઇલ કરતી વખતે ઉદ્ભવતી ભૂલો (Compile-time Errors)
  2. પ્રોગ્રામના અમલ દરમિયાન ઉદ્ભવતી ભૂલો (Run-time Errors during execution of program)

અપવાદરૂપ પરિસ્થિતિના વ્યવસ્થાપનના ફાયદા (Advantages of Exception Handling)
જાવા પ્રોગ્રામમાં અપવાદરૂપ પરિસ્થિતિના વ્યવસ્થાપનના કેટલાક ફાયદા નીચે મુજબ છે :

1. તેના કારણે પ્રોગ્રામનો અધવચ્ચે અચાનક અંત આવી જતો નથી.
2. તે આપણને પ્રોગ્રામના સામાન્ય પ્રવાહને જાળવવામાં મદદરૂપ નીવડે છે.
3. તેને કારણે પ્રોગ્રામનો અમલ કરતાં સમયે અનપેક્ષિત પરિણામો મળતાં નથી.
4. તે સામાન્ય સૂચનાઓને બદલે અપવાદ- વ્યવસ્થાપન માટેની અલગ સૂચના લખવાની છૂટ આપે છે.
5. ભૂલના પ્રકારોને એક જૂથમાં લાવી શકાય છે અને પ્રોગ્રામમાં અલગ તારવી શકાય છે.
6. ક્લાયન્ટને પ્રોગ્રામ પૂરા પાડતા પહેલાં, પ્રોગ્રામ ડીબગ થયેલ છે, તેની ખાતરી આપી શકાય છે.
7. પ્રોગ્રામનો અમલ કરતી વખતે અમલ દરમિયાન ઉદ્ભવતી વિવિધ ભૂલોને પકડી પાડવા સરળ તંત્ર-વ્યવસ્થા પૂરી પાડે છે.