Errors සහ Exceptions කලමනාකරණය කිරීම (Exception Handling)

කිසියම් වැඩසටහනක් 100% ක්ම දෝශ රහිතව ලිවීම ඉතාම අසීරු කාරණයකි. වැඩසටහනේ විශාලත්වය වැඩිවත්ම මෙහි අසීරුතාව සීඝ්‍රයෙන් වැඩිවේ. Program එක සාර්ථකව compile වීම යනු එම වැඩසටහන දෝශරහිත යයි සැලකීමට සාධකයක් නොවේ. Program එකෙහි logical errors තිබිය හැක. logical errors යනු වැඩසටහන නියමාකාර ලෙස ක්‍රියානොකිරීමට(අපේක්ෂා කල පරිදි ක්‍රියා නොකිරීමට) හේතුපාදක වන කාරණයකි.

ජාවා වැඩසටහනක ඇතිවිය හැකි errors ආකාර දෙකකි.

• Compile-time errors
• Run-time errors

සියලුම syntax errors හෙවත් භාශාවේ කාරක රීති වලට පටහැනි අවස්ථා Compile-time errors ලෙස සැලකේ. මෙහිදී ජාවා compiler එක .java file එක මගින් .class file එක නොසාදයි. එනම් වැඩසටහන compile නොකෙරේ.

*Compile-time errors සඳහා උදාහරණ.

ඉහත වැඩසටහනේ 3 වන line එකෙහි ඇති statement එක semicolon ";" එකකින් අවසන් කර නැත එය syntax error එකකි. එමනිසා එය compile කිරීමේදී පහත දෝශය පෙන්වයි.

* Run-time errors සඳහා උදාහරණ

මෙහිදී program එක සාර්ථකව compile වුවද එය run කිරීමට යාමේදී විවිධ ගැටලු ඇතිවේ.

• නිඛිල සංඛ්‍යා 0න් බෙදිම
• Array එකක සීමාවෙන් පිට element එකක් access කිරීමට යාම
• කිසියම් array එකක් තුලට නොගැලපෙන data type එකකින් යුතු අගයක් ඇතුලු කිරීම
• null object එකක attribute හෝ methods භාවිතා කිරීම(access)

මේ සඳහා තවත් උදාහරණ රාශියක් ඇත.

දැන් අපි Run-time erors සඳහා උදාහරණ කිරිපයක් බලමු.

*Division by zero

class Runtime1{
 public static void main(String args[]){
  int a=5;
  int b=6;
  int c=10;
  int res=c/(b-a-1);
  System.out.println(res);
 }
}

මෙම වැඩසටහන සාර්ථකව compile වුවද run වීමේදී පහත දෝශය පෙන්වයි. එයට හේතුව line 6 දී (b-a-1) කොටසෙහි අගය 0 වීමයි.

* Array index out of bounds

class Runtime2{
 public static void main(String args[]){
  int arr[]=new int[5];
  int i=arr[10];
 }
}

මෙය run වීමේදී පහත දෝශය පැන නගී

දැන් අපි Run-time errors පිලිබඳ පුලුල්ව සාකච්ඡා කරමු.
Run-time errors වර්ග 2කි

1. Errors
2. Exceptions

අපි මුල්ම පාඩම් වලදී ඉගෙනගත්තා ජාවා තුල සියලුම දේවල් class ලෙස සලකන බව. ඒ අනුව Errors හා Exception සඳහාද ජාවා තුල class 2ක් තිබෙනවා.

Error class

මෙම ආකාරයේ errors හඳුන්වන්නේ abnormal errors හෙවත් අස්වාභාවික errors ලෙසින්. වැඩසටහනක් ලිවීමේදී අප එම වැඩසටහන තුලින් සාමාන්‍යයෙන් මෙම ආකාරයේ errors අපේක්ෂා කරන්නේ නෑ එනම් ඒවා handle කිරීමට යන්නේ නෑ.

මේ සඳහා උදාහරණ.

• Virtual machine එකේ දෝශ
• ThreadDeath errors

Exception class

ජාවා වැඩසටහන් තුල Error handle කරනවා යනු මෙම exceptions නියමාකාරයෙන් handle කිරීමයි. මෙහි වැදගත්කම වනුයේ run-time එකේදී කලින් අපේක්ෂා කල errors ඇතිවුවහොත් program එක terminate වීම හෝ වැරදි ප්‍රතිඵලයක් ලබාදීමෙන් වලක්වා ගැනීමයි.

බහුල වශයෙන්  හටහන්නා Exception කිහිපයකට උදාහරණ

•  ArithmeticException
•  ArrayIndexOutOfBoundsException
•  IOException
•  FileNotFoundException
•  NumberFormatException
•  StringOutOfBoundsException

දැන් අපි බලමු ක්‍රමලේඛයක් තුලදී Exception handle කරන්නේ කියලා.
මේ සඳහා විධි 2ක් තිබෙනවා. 

1) Throw Out (Ignore)

මෙහිදී යම් අපේක්ෂා කල Exception එකක් හටගතහොත් එය ඉවත දැමීම නොහොත් නොසලකා හැරීම සිදුකෙරෙනවා. ඇතැම් අවස්ථා වලදී මෙම ක්‍රමය යොදාගත්තත් මෙය සුදුසුම ක්‍රමය නොවේ.

දැන් අපි බලමු මෙම ක්‍රමය භාවිතා කරන අයුරු.

Syntax:

    methodName throws ExceptionName{
        ..method body
    }

උදා:

import java.io.*;

class ExceptionEx1{
 public static void main(String args[]) throws IOException{
  InputStreamReader isr=new InputStreamReader(System.in);
  BufferedReader br=new BufferedReader(isr);
  System.out.print("Enter your name : ");
  String name=br.readLine();
 }
}

2) Catch and handle

සලකනු ලබන code segment එකක් තුල යම් අපේක්ෂිත Exception එකක් පැනනැගුනහොත් සිදුකලයුතු ක්‍රියාමාර්ගය පිලිබඳ මෙහිදී සඳහන් කෙරේ ජාවා වැඩසටහනක Exception handle කිරීම සඳහා මෙම ක්‍රමය ඉතාම සුදුසු වේ. 

Syntax:

        try{
            ..................
            ...code segment...
            ..................
        }catch(ExceptionName1 exObj){
            ..................
            ..handling error1..
            ..................
        }catch(ExceptionName2 exObj){
            ..................
            ..handling error2..
            ..................
        }catch(ExceptionNamen exObj){
            ..................
            ..handling errorn.
            ..................
        }finally{
            ..................
            ..final action....
            ..................
        }

උදා:

import java.io.*;

class ExceptionEx2{
 public static void main(String args[]) {
  int age=0;
  InputStreamReader isr=new InputStreamReader(System.in);
  BufferedReader br=new BufferedReader(isr);
  System.out.print("Enter your age : ");
  try{
   String ageStr=br.readLine(); 
   age=Integer.parseInt(ageStr);
  }catch(IOException ex1){
   System.out.println("I/O Error! "+ ex1.getMessage());
  }catch(NumberFormatException ex2){
   System.out.println("Invalid number format! "+ ex2.getMessage());
  }
 }
}

output:

Errors catch කිරීමේදී ඒවා අපේක්ශිත අනුපිලිවෙලට සිදුකලයුතු බව මතකතබා ගත යුතුය. මෙහිදී exceptions ඇතිවිය හැකි අනුපිළිවෙල මෙන්ම class hierarchy එකද වැදගත් වේ. class hierarchy එකේ පහලින් ඇති errors මුලින් catch කර ඉහල ඇති ඒවා පසුව catch කිරීම සිදුකලයුතුය. class hierarcy එක බලාගැනීමට java documentation එක පරිශීලනය කලයුතුවේ.

finally  block එක පිලිබඳව

මෙතුල අන්තර්ගත කරන code segments අනිවාර්‍යයෙන්ම execute කිරීම සිදුවේ(Exception එකක් හටගත්තත් නැතත්). finally statement එක යෙදෙන අවස්ථා සඳහා උදාහරණ ලෙස open කරන ලද stream එකක් close කිරීම වැනි අවස්ථා දැක්විය හැකිය.

Exception class එකෙහි ඇති getMessage() method එක පිලිබඳව
මෙමගින් Exception එකට අදාල වැඩිදුර තොරතුරු String එකක් ලෙස return කරයි. 
 

අපි දැන් බලමු අපිවිසින් අපේම(our own) Exception සාදන ආකාරය සහ ඒවා throw කරන්නේ කවර ආකාරයෙන්ද කියලා. 
මෙහිදී මූලිකවම සිදුකරන්නේ Exception නම් predefined class එක extend කරමින් නව class එකක් සෑදීමයි.
උදා: OwnExceptionDemo.java

/**     
*class  : OwnExceptionDemo     
*Author : Kanishka Dilshan     
*Purpose: Demonstrate howto write custom exceptions   
*Blog   : http://javaxclass.blogspot.com     
*/ 

class Printer{
 /*assumption: 
  *printing 1 page will decrease the ink level by 1
  */
 int inkLevel;//minimum=0
 int pages;
 
 public Printer(int p,int inkLevel){
  pages=p;
  this.inkLevel=inkLevel;
 }

 public void print(){
  try{
   if(inkLevel==0){
    throw new EmptyCartridgeException();
   }else if(pages==0){
    throw new NoPagesException();
   }else{
    pages-=1;
    inkLevel-=1;
    System.out.println("Page completed.");
   }
  }catch(EmptyCartridgeException ecEx){
   System.err.println(ecEx.getMessage());
  }catch(NoPagesException npEx){
   System.err.println(npEx.getMessage());
  }
 }
}

class NoPagesException extends Exception{
 NoPagesException(){
  super("No pages in the paper tray!");
 }
} 

class EmptyCartridgeException extends Exception{
 EmptyCartridgeException(){
  super("Cartridge is empty. Please refill it");
 }
}

class OwnExceptionDemo{
 public static void main(String args[]){
  //creating Printer object and and calling print() method
  System.out.println("---------p1 Printer object---------");
     Printer p1=new Printer(5,100);
  for(int i=0;i<8;i++) //this will cause NoPagesException
   p1.print();

  System.out.println("\n---------p2 Printer object---------");
  Printer p2=new Printer(5,4);
  for(int i=0;i<5;i++) //this will cause EmptyCartridgeException
   p2.print();
 }
}

මෙම වැඩසටහනෙහි output එක පහත පරිදි වේ.

දැන් ඔබට Error handling පිලිබඳව යම් වැටහීමක් ඇතැයි සිතමි. වැඩිදුරටත් අභ්‍යාසයේ යෙදීමෙන් තවදුරටත් එය තහවුරු කරගැනීමට උත්සාහ ගන්න. ගැටලු සහගත තැන් ඇත්නම් ඒවා ඉදිරිපත් කරන්න. 

මීලඟ පාඩමෙන් අපි Threads පිලිබඳ අධ්‍යයනය කරමු.