try-catch-finally

19 වන පාඩම(try-catch-finally)

ජාව වල programe රන්  සමහර වෙලාවට exception සිදුවෙනව. මෙම exception සිදු වුනාම programe එක එතනින් එහාට වැඩ කරන්නෙ නෑ.

·         හිතන්න user ගෙන් integer read කරනකොට  double value  එකක් දුන්නොත්

·         Operation කරනකොට අගයක් 0 න් බෙදුවොත්.

·         Array (ඉදිරියේ  lesson එකක්) වල size එකට වඩා වැඩි index එකක index එකකට acces වෙන්න හැදුවොත්.

ඉහත අවස්තාවල programe එක compile වෙනව නිවැරදිව.නමුත් රන් වෙනකොට තමයි මෙම exeption වෙන්නෙ.එහෙම වෙනකොට programe එක නතර නොවී ඊලගට කලයුතුදේ කරගන යන්න මෙම try-catch ප්‍රයෝජනවත් වෙනව.

ඒ වගෙම scanner වගෙ resources අවසානයෙ close කරන්න පුලුවන් වෙනව Exception සිදුවුන අවස්තාවෙ උනත්.

මේක හරිම ලේසියි.

කරන්න තියෙන්නෙ error එකක් වෙන්න ඉඩ තියන කොටස try block එක ඇතුලෙ ලියන එක විතරයි. try block එක ඇතුලෙ වරදක් උනොත්  programe එක නතර නොවී catch block එකට යනව ඒකෙ ඇතුලෙ තියන statement ටික execute වෙනව .finally block එක අත්‍යවශ්‍ය නෑ.ඒක හැමවෙලාවෙම execute වෙනව එහි ඇතුලත තියන statement.

මුලින්ම try-catch විතරක් බලමු.තේරුම්ගන්න ඒකෙ තියන පොඩි අවාසියක් පහල example එකේ.

import java.util.Scanner;

public class errors

 {

            public static void main(String[] args)

            {          try

                        {

                        Scanner s=new Scanner(System.in);

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        s.close();

                        }

                        catch(Exception e)

                        {

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

            }

}

ඉන්පුට් එක integer නොදුන්නොත් එතනින් පහල try block එකෙ කිසිම statement එකක් execute වෙන්නෙ නෑ.

exception happened in the try block. exception =java.util.InputMismatchException කියල ප්‍රින්ට් වෙනව.මෙතන Exception කියනෙක වෙනුවට අපිට ඕන specific එක දෙන්න පුලුවන්.අපි  දන්නෙ නැත්නම් හරියටම වෙන්න යන Exception එක  මේ විදියට දෙන්න පුලුවන්.

Exception කියනෙක යොදාගන්නවනම් util package එක ඉම්පොර්ට් කරන්න ඕනි නෑ.

මේ උදාහරනයෙදි j වලට  integer අගයක්නෙ එන්න ඕනි.

InputMismatchException කියන exception එක තමයි වෙන්නෙ වෙන අගයක් දුන්නොත්.

Exception වෙනුවට InputMismatchException දෙන්න පුලුවන් අල්ලන Exception එකට .ඒකට

java.util.InputMismatchException කියන class එක import කරගන්න ඕනි.

import java.util.InputMismatchException;කියල දෙන්න පුලුවන් ක්ලාස් එකේ උඩින්ම.

මෙතනදි scanner එකත් import කරානෙ.තව exeption ආවොත් ඒවටත් import කරන්න වෙනව.ඒක එපාවෙනවනෙ.

අපි util package එකේ සේරම import කරගන්නව ලේසි වෙන්න.

import java.util.*;

public class errors

 {

            public static void main(String[] args)

            {          try

                        {

                        Scanner s=new Scanner(System.in);

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        s.close();

                        }

                        catch(InputMismatchException e)

                        {

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

            }

}

ඕනම package එකක සේරම class import කරගන්න .*; use කරනව.

දැන් අගයන් දෙකක් අරගන එකක් 0 කරල අනෙක් අගය 0 බෙදන operation එක කරල බලන්න.

java.lang.ArithmeticException: / by zero

කියන ArithmeticException එක වෙනව.

ArrayIndexOutOfBoundsException වෙනව Array (ඉදිරියේ  lesson එකක්) වල size එකට වඩා වැඩි index එකක index එකකට acces වෙන්න හැදුවොත්.

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111

දැන් හිතන්න exeption එක උනාම ඊට පහල try block එකෙ ඒව execute වෙන්නැත්නම් කොහොමද  scanner s කියනෙක close කරන්නෙ.

Catch block එකට දානවද? එහෙම දාන්නනම් 

Scanner s=new Scanner(System.in);

කියන statement එක try block එකට පිටින් දාන්න වෙනව.

public static void main(String[] args)

            {         

            Scanner s=new Scanner(System.in);

            try

                        {

                       

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        s.close();

                        }

                        catch(Exception e)

                        {

                                    s.close();

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

            }

මෙතනදි නිකරුනේ s.close(); එකම statement එක use කරනව.finally block එක use කරොත් එහෙම වෙන්නෙ නෑ.

import java.util.Scanner;

public class errors

 {

            public static void main(String[] args)

            {         

            Scanner s=new Scanner(System.in);

            try

                        {

                       

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        }

                        catch(Exception e)

                        {

                                   

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

                        finally

                        {

                                    s.close();

                        }

            }

}

.cacth block එකට යන්නෙ try block එකේ අව්ලක් නම් විතරනෙ.ඒත් Finally block එකේ ඒව හැමවෙලාවෙම රන් වෙනව.ඒ නිසා s.close(); එක finally block එකේ ලිව්වම හරි.

තැනට ගැලපෙන විදියට try-catch-finally යොදාගන්න.සමහර අවස්තාවල finally block එක අවශ්‍ය වෙන්නෙ නෑ.

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111ජාව 7 හෝ  8 use කරනවනම් සමහර resources initialize කරන්න    යොදාගන්නව try() පහත විදියට  .මතක තියාගන්න පහල example හරි නොගියොත්ජාව version එක බලන්න,

import java.util.Scanner;

public class errors

 {

            public static void main(String[] args)

            {         

           

            try(Scanner s=new Scanner(System.in))

                        {

                       

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        }

                       

            }

}

මෙතනදි s.close(); කියනෙක සිදුවෙනව.නමුත් අනෙක් exception අල්ලන්නෙ නෑ.මේ ක්‍රමය හරියටම තේරුම්ගන්න .මෙතනින් වෙන්නෙ බාවිත කරපු resourse එක close කරනෙක.පහල විදියට යොදාගත්තනම් හරි.

import java.util.Scanner;

public class errors

 {

            public static void main(String[] args)

            {         

           

            try(Scanner s=new Scanner(System.in))

                        {

                       

                        int j=s.nextInt();

                        System.out.println("j="+j/0);

                        }

                        catch(Exception e)

                        {

                                   

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

                       

            }

}

Nested try-catch එහෙමත් යොදාගන්න පුලුවන්.බලන්න  exception ගොඩක් අල්ලන  විදියක් ,

import java.util.*;

public class errors2

 {

            public static void main(String[] args)

            {         

           

            try(Scanner s=new Scanner(System.in))

                        {

                       

                        int j=s.nextInt();

                        System.out.println("j="+j);

                        j=j/0;

                        }

                        catch(InputMismatchException e)

                        {

                                   

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

                        catch(ArithmeticException e)

                        {

                                   

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

                        catch(Exception e)

                        {

                                   

                                    System.out.println("exception happened in the try block. exception ="+e);

                                   

                        }

                        finally

                        {

                                    System.out.println("always execute");

                        }

                       

            }

}

මන් highlight කරල තියන block එක අවසානෙට තියෙන්න ඕනි.ඒක මුලින් දැම්මොත් එහෙම error එකක් එයි.මේ example එකේ විදියට catch ඕනම   ප්‍රමානයක් සුදුසු විදියට යොදාගන්න පුලුවන්.