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 ඕනම ප්‍රමානයක් සුදුසු
විදියට
යොදාගන්න පුලුවන්.
