OVERLOADING,OVERRIDING,DAN
EXCEPTION
1.OVERLOADING
Merupakan Suatu Function yang memiliki
parameter , dan function tersebut dapat memiliki nama function yang sama dengan
yang lainnya dengan syarat jumlah parameter mesti berbeda atau bisa kita bilang
Situasi di mana beberapa rutin dalam sebuah program dapat mempunyai nama sama
tetapi berbeda jenis parameter dan/utau jenis return value.
lebih Jelasnya Overloading secara
singkat :
·
Nama Method Boleh Sama , Tapi Jumlah Parameter Mesti berbeda
·
Nilai Yang Di Return Harus memiliki Tipe yang sama
Contoh studi kasus :
public class Hitung
{ static int tambah(int x, int y)
{ return
x+y;
}
static double tambah(double x, double y)
{ return
x+y;
}
static int tambah(int x, int y, int z)
{ return
x+y+z;
}
static void tambah2(int x, int y)
{ System.out.println("x"+x+"
+ y"+y+"="+(x+y));
}
public static void
main(String[] a)
{ int
x,y;
x=2; y=x+3;
x=tambah(2,3);
System.out.println("1. "+x);
System.out.printf("2. %.2f
\n",tambah(2.3, 4.1));
System.out.println("3. "+tambah(5,
12, 3));
System.out.println("4. "+tambah(100,
0.5));
System.out.println("5. "+tambah(2.5,
4));
System.out.println("6. "+tambah(tambah(x*2,
(x*2-y)), tambah((y-x),
tambah(7,
3), 2)));
System.exit(0);
}
}
- Overloading bisa juga diartikan dengan istilah sebagai berikut, metode dengan nama yang sama, parameter yang berbeda, me-return value dengan return type yang berbeda.
- Dapat digunakan ketika operator yang sama memiliki implementasi yang berbeda.
Tujuan : memudahkan
penggunaan/pemanggilan method dengan fungsionalitas yang mirip.Aturan
Pendeklarasian Method Overloading yaitu:
- Nama method harus sama
- Daftar parameter harus berbeda
- Return type boleh sama, juga boleh berbeda
Daftar Parameter Pada Overloading
Perbedaan daftar parameter bukan hanya terjadi pada
perbedaan banyaknya parameter, tetapi juga urutan dari parameter tersebut.
Misalnya saja dua buah parameter berikut ini :
function_member(int x, String n)
function_member(String n, int x)
Dua parameter tersebut juga dianggap berbeda daftar parameternya.
Misalnya saja dua buah parameter berikut ini :
function_member(int x, String n)
function_member(String n, int x)
Dua parameter tersebut juga dianggap berbeda daftar parameternya.
Daftar Parameter Pada Overloading
Daftar parameter tidak terkait dengan penamaan
variabel yang ada dalam parameter.
Misalnya saja 2 daftar parameter berikut :
function_member(int x)
function_member(int y)
Dua daftar parameter diatas dianggap sama karena yang berbeda hanya penamaan variabel parameternya saja.
Ciri-ciri Overloading:
1.Nama method harus sama
2.Daftar Parameter harus berbeda
3.Return type boleh sama boleh berbeda
Contoh Overloading dengan constructor:
#include
class CRectangle {
int width, height;
public:
CRectangle ();
CRectangle (int,int);
int area (void) {return (width*height);}
};
CRectangle::CRectangle () {
width = 7;
height = 9;
}
CRectangle::CRectangle (int a, int b) {
width = a;
height = b;
}
int main () {
CRectangle rect (2,4);
CRectangle rectb;
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
}
OUTPUT>>
adapun contoh lainnya:
Misalnya saja 2 daftar parameter berikut :
function_member(int x)
function_member(int y)
Dua daftar parameter diatas dianggap sama karena yang berbeda hanya penamaan variabel parameternya saja.
Ciri-ciri Overloading:
1.Nama method harus sama
2.Daftar Parameter harus berbeda
3.Return type boleh sama boleh berbeda
Contoh Overloading dengan constructor:
#include
class CRectangle {
int width, height;
public:
CRectangle ();
CRectangle (int,int);
int area (void) {return (width*height);}
};
CRectangle::CRectangle () {
width = 7;
height = 9;
}
CRectangle::CRectangle (int a, int b) {
width = a;
height = b;
}
int main () {
CRectangle rect (2,4);
CRectangle rectb;
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
}
OUTPUT>>
adapun contoh lainnya:
01.using System;
02.
03.class overloadingMethod
04.{
05.public void biodata()
06.{
07.Console.WriteLine("Biodataku");
08.this.biodata("Aji");
09.}
10.
11.public void biodata(string nama)
12.{
13.Console.WriteLine("Namaku : {0}", nama);
14.this.biodata(23, "Pria");
15.}
16.
17.public void biodata(int umur, string kel)
18.{
19.Console.WriteLine("Umurku : {0}", umur);
20.Console.WriteLine("Jenis Kelamin : {0}",
kel);
21.
22.}
23.}
24.
25.class latihan
26.{
27.static void Main()
28.{
29.overloadingMethod latOverloading
= new overloadingMethod();
30.latOverloading.biodata();
31.Console.ReadLine();
32.}
33.}
Hasil outputnya adalah sebagai berikut :
Biodataku
Namaku : Aji
Umurku : 23
Jenis Kelamin : Pria
Biodataku
Namaku : Aji
Umurku : 23
Jenis Kelamin : Pria
Namaku : Aji
Umurku : 23
Jenis Kelamin : Pria
2.OVERRIDING
Merupakan Suatu Keadaan Dimana
kelas anak dapat mengubah atau bisa kita bilang memodifikasi atau memperluas
data dan method pada kelas induk.
Keuntungan Overriding : dapat menambahkan sifat / atribut pada kelas induk nya
Keuntungan Overriding : dapat menambahkan sifat / atribut pada kelas induk nya
lebih Jelasnya Overloading secara
singkat :
·
Mendefinisikan method dengan nama sama pada class yang berbeda.
·
Konsep dapat di manfaatkan dalam beberapa kasus inheritance, di mana
menginginkan penamaan method dengan nama sama namunberbeda dalam
impelementasinya.
ciri - ciri overriding
1.Nama method harus sama
2.Daftar parameter harus sama
3.Return type harus sama
1.Nama method harus sama
2.Daftar parameter harus sama
3.Return type harus sama
Contoh studi kasus :
class Kendaraan {
…………..
public String getJenis() {
System.out.println(“Harga BBM turun”);
}
}
class Motor extends Kendaraan {
…………..
public String getJenis() {
System.out.println(“Harga BBM premium
4000 rupiah”);
}
}
3.EXCEPTION29DES
Merupakan Kesalahan atau error sering terjadi
pada saat membuat program, ini yang membuat kesal para pemula programmer untuk
itu menghindari dari kesalahan atau eror Java menyediakan fasilitas berupa
mekanisme penanganan exception. Bisa di kata kan bahwa Exception adalah
singkatan dari Exceptional Events atau dalam bahasa indonesianya kesalahan
(error) yang terjadi pada saat pembuatan program dan saat runtime, mengakibatkan
gangguan pada alur exekusi.
Kesalahan dalam program java terdapat beberapa tipe sebagai contoh kesalahan pembagian 0, mengakses elemen di luar jangkauan array dan input yang tidak benar. Exception merupakan sebuah subclasses baik secara langsung atau tidak langsung, sehingga exception di bagi 2 kategori class yaitu : Error Class dan Exception Class
Exception menunjukkan bahwa class tersebut dapat di terima oleh user program. Tetapi Exception class di gunakan untuk memperbaiki beberapa kesalahan pada kode program sebagai contoh Exception adalah pembagi oleh 0 dan error pada saat array melakukan tindakan di luar jangkauan. Error class menpunyai fungsi untuk menangani kesalahan atau error yang sering muncul pada saat program di jalankan. Tetapi kesalahan pada program merupakan di luar control user karena kemunculan di sebabkan oleh run-time environment. Sebagai contoh out of memory dan harddisk carsh.
Kesalahan dalam program java terdapat beberapa tipe sebagai contoh kesalahan pembagian 0, mengakses elemen di luar jangkauan array dan input yang tidak benar. Exception merupakan sebuah subclasses baik secara langsung atau tidak langsung, sehingga exception di bagi 2 kategori class yaitu : Error Class dan Exception Class
Exception menunjukkan bahwa class tersebut dapat di terima oleh user program. Tetapi Exception class di gunakan untuk memperbaiki beberapa kesalahan pada kode program sebagai contoh Exception adalah pembagi oleh 0 dan error pada saat array melakukan tindakan di luar jangkauan. Error class menpunyai fungsi untuk menangani kesalahan atau error yang sering muncul pada saat program di jalankan. Tetapi kesalahan pada program merupakan di luar control user karena kemunculan di sebabkan oleh run-time environment. Sebagai contoh out of memory dan harddisk carsh.
Dalam java dikenal adanya konsep method
call stack. Bila ada method a() memanggil method b(), dan method b() memanggil
method c(),
Method yang paling atas dari stack (method c() dalam
hal ini) adalah method yang saat ini sedang dijalankan. Bila method c() telah
selesai dijalankan,
Dalam java terdapat 2 jenis
object berdasarkan dapat dilempar atau tidaknya object itu dalam suatu method
call stack , yaitu:
1.Object yang dapat dilempar
dalam method call stack. Object ini adalah instansiasi dari kelas yang
merupakan subclass dari java.lang.Throwable.
2.Object yang tidak dapat
dilempar dalam method call stack.
Berikut ini adalah class diagram untuk menjelaskan hirarki dari
kelas java.lang.Throwable :
1) Kelas-kelas turunan java.lang.Throwable biasanya menyatakan suatu kondisi yang
tidak diharapkan selama eksekusi program [1].
2) Object dari kelas-kelas turunan java.lang.Error biasanya dilemparkan untuk menyatakan
adanya suatu kegagalan dalam
JVM, seperti kehabisan memory (yang akan melemparkan object dari kelas
java.lang.outOfMemoryError ) [1&3] .
Biasanya program kita tidak dapat direcovery bila object dari
subclass java.lang.Error dilemparkan [2&3].
Secara teknis, kelas-kelas turunan dari java.lang.Error tidak dapat disebut sebagai exception
(karena mereka bukan subclass darijava.lang.Exception) [2].
3) Object dari kelas-kelas turunan java.lang.Exception biasanya dilemparkan untuk menyatakan
suatu resource atau
suatu kondisi yang dibutuhkan oleh program tidak tersedia.
4) Object dari kelas-kelas turunan java.lang.RuntimeException biasanya dilemparkan untuk menyatakan
adanya error dalam program.
Contoh error dalam program adalah ketika kita berusaha mengakses suatu array
dengan index yang lebih besar dari jumlah element-1 (yang akan melemparkan java.lang.ArrayIndexOutOfBoundsException).
Contoh:
|
Program 1
|
|
public
class MyRuntimeException1 {
public static void main(String[] args) {
String[] myString = {"halo", "apa",
"kabar"};
System.out.println(myString[100]);
}
}
|
|
Program di atas akan menghasilkan runtime error sbb :
Exception
in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at exception.MyRuntimeException1.main(MyRuntimeException1.java:6)
|
· Berdasarkan
dicek atau tidaknya suatu object yang dileparkan, throwable object terbagi
menjadi 2, yaitu :
1.Checked throwable-object.
Checked throwable-object adalah throwable-object yang HARUS di “handle or declare”
oleh programmer (pengertian “handle or declare” ada pada subbab 4: Checked
exception).Kelas dan semua subclass dari java.lang.Throwable (kecuali kelas dan subkelas java.lang.Error dan java.lang.Runtime
Exception nya adalah checked throwable-object.
2.Unchecked throwable-object
Unchecked throwable-object adalah throwable-object yang TIDAK HARUS di “handle or declare”.Semua kelas dan
subclas dari java.lang.Error dan java.lang.RuntimeException adalah unchecked throwable-object. Pada referensi java, tidak ada yang disebut sebagai checked throwable-object dan unchecked
throwable-object, yang ada adalah checked-exceptiondan unchecked-exception. Pada
tulisan ini, checked throwable-object digunakan untuk menggantikan checked
exception dan unchecked throwable-object dipergunakan untuk menggantikan
unchecked exception, hal ini disebabkan karena pada referensi java lain, java.lang.Error termasuk pada unchecked exception,
padahal java.lang.Error secara teknis adalah bukan exception.
KELAS java.lang.Throwable, BAGAIMANA MEMBUAT KELAS EXCEPTION BARU DAN BAGAIMANA MELEMPAR EXCEPTION SECARA MANUAL
Kelas java.lang.Throwable memiliki sebuah method yang sangat
penting, yaitu printStackTrace().
Method ini berfungsi untuk mencetak stack trace dari tempat dimulainya
exception terjadi (dari method paling baru yang dieksekusi sampai dengan method
yang pertama kali dieksekusi).
Contoh :
|
Program
2
|
|
package
exception;
public
class MyThrowable1 {
public static void main(String[] args) {
try {
System.out.println("Sebelum pelemparan " +
"object MyThrowableClass");
new MyClass().e();
System.out.println("Setelah pelemparan " +
"object MyThrowableClass");
}
catch(MyThrowableClass t) {
System.out.println("Di dalam blok catch");
t.printStackTrace();
}
}
}
class
MyThrowableClass extends java.lang.Throwable {
public MyThrowableClass() {
super("Hallo, ini percobaan");
}
}
class
MyClass {
void a() throws MyThrowableClass {
throw new MyThrowableClass();
}
void b() throws MyThrowableClass {
a();
}
void c() throws MyThrowableClass {
b();
}
void d() throws MyThrowableClass {
c();
}
void e() throws MyThrowableClass {
d();
}
}
|
|
Program di atas akan menghasilkan :
Sebelum pelemparan object MyThrowableClass
Di dalam blok catch
exception.MyThrowableClass: Hallo, ini percobaan
at
exception.MyClass.a(MyThrowable1.java:25)
at
exception.MyClass.b(MyThrowable1.java:28)
at
exception.MyClass.c(MyThrowable1.java:31)
at exception.MyClass.d(MyThrowable1.java:34)
at
exception.MyClass.e(MyThrowable1.java:37)
at
exception.MyThrowable1.main(MyThrowable1.java:7)
|
· Untuk membuat kelas exception baru,
kita harus meng-extends kelas java.lang.Exception.
Contoh :
|
Program
03
|
|
class
MyException extends java.lang.Exception {
}
|
· Keyword throw dapat dipergunakan untuk melempar
object bertipe class atau subclass dari java.lang.Throwable.
Contoh :
|
Program
4
|
|
public
class MyThrow1 {
private static void myThrow() throws Exception {
throw new Exception();
}
}
|
KONSEP try-catch-finally
Ketika sebuah exception terjadi, maka
kejadian tersebut dikatakan sebagai exception yang dilemparkan (thrown).
1. Kode yang bertanggung jawab untuk melakukan
sesuatu ketika exception dilemparkan disebut dengan exception handler.
2.Ketika ada
sebuah exception dilemparkan dan ada exception handler yang bertanggung jawab
terhadap jenis exception tersebut, maka exception handler dikatakan menangkap (catch) exception.
3. Mekanisme exception adalah mentransfer
eksekusi program dari tempat terjadinya exception ke exception handler yang
sesuai.
4. try, catch, finally, throw, dan throws adalah keyword-keyword yang
berhubungan dengan proses pelemparan object (instance dari
subclassjava.lang.Throwable) [1].
Akan tetapi kita biasanya keyword-keyword tersebut hanya akan digunakan untuk
instance dari subclassjava.lang.Exception saja [1&2].
5.Berikut
ini adalah peta try-catch-finally [1] :
Beberapa aturan yang berhubungan dengan peta try-catch-finally di atas adalah:
1) Harus ada blok try
2) Blok try harus
diikuti oleh 1 atau lebih blok catch dan atau 1 blok finally.
3) Blok try dapat hanya diikuti oleh blok catch saja, atau blok try dapat
hanya diikuti oleh blok finally saja. Akan tetapi tidak boleh kedua-duanya (catch dan finally)
tidak mengikuti blok try.
4) Bila setelah
blok try terdapat blok catch dan blok finally, maka blok finally harus terletak setelah blok catch.
5) Antar blok try-catch-finally tidak boleh ada statement.
Berikut ini adalah contoh
potongan program dengan blok try-catch-finally:
|
try {
//Guarded region
}
catch(MyFirstException e) {
//exception handler untuk
object
//bertipe MyFirstException
}
catch(MySecondException e) {
//exception handler untuk object
//bertipe MySecondException
}
Finally {
//Blok ini pasti dijalankan
}
|
· Berikut ini adalah contoh program
blok-try-catch :
|
Program 05
|
|
package
exception;
class ExceptionA extends
Exception {}
class ExceptionB
extends ExceptionA {}
class ExceptionC
extends Exception {}
public class
MyCatch1 {
public static void main(String[] args) {
System.out.println("Sebelum blok try");
try {
System.out.println("Statement sebelum exception");
pelemparException();
System.out.println("Statement setelah exception");
}
catch(ExceptionB eb) {
System.out.println("Dalam blok catch(ExceptionB eb)");
}
catch(ExceptionA ea) {
System.out.println("Dalam blok catch(ExceptionA ea)");
}
catch(ExceptionC ec) {
System.out.println("Dalam blok catch(ExceptionC ec)");
}
finally {
System.out.println("Dalam blok finally");
}
System.out.println("Setelah blok try");
}
public static void pelemparException()
throws ExceptionA, ExceptionB, ExceptionC {
throw new ExceptionA();
}
}
|
|
Program di atas akan menghasilkan :
Sebelum
blok try
Statement
sebelum exception
Dalam
blok catch(ExceptionA ea)
Dalam blok finally
Setelah blok try
|
· Skenario umumdari blok try-catch-finally
 |
· Ketika suatu exception terjadi dan
tidak ada catch yang sesuai untuk menangkap exception
itu dalam suatu method, maka exception tersebut akan dilempar ke method
pemanggil method saat ini (hal ini disebut dengan exception propagation) [1&2]. Hal ini akan
terjadi terus sampai akhirnya bila semua method dalam method call stack tidak
ada yang bisa menangkap exception tersebut, maka exception tersebut akan
dilemparkan ke JVM dam akhirnya program akan berhenti karena exception [1].
Contoh :
|
Program
6
|
|
package
exception;
public
class MyException1 {
public static void main(String[] args) {
Percobaan obj = new Percobaan();
obj.a();
}
}
class
Percobaan {
void d() {
System.out.println("Dalam method d(). " +
"Sebelum operasi pembagian.");
int i = 2 / 0; //Pasti terjadi exception
System.out.println("Dalam method d(). " +
"Setelah operasi pembagian.");
}
void c() {
System.out.println("Dalam method c(). " +
"Sebelum pemanggilan method lain.");
d();
System.out.println("Dalam method c(). " +
"Setelah pemanggilan method lain.");
}
void
b() {
System.out.println("Dalam method
b(). " +
"Sebelum pemanggilan method lain.");
c();
System.out.println("Dalam method b(). " +
"Setelah pemanggilan method lain.");
}
void a() {
System.out.println("Dalam method a(). " +
"Sebelum pemanggilan method lain.");
b();
System.out.println("Dalam method a(). " +
"Setelah pemanggilan method lain.");
}
}
|
|
Program di atas akan menghasilkan :
Dalam method a(). Sebelum pemanggilan method lain.
Dalam method b(). Sebelum pemanggilan method lain.
Dalam method c(). Sebelum pemanggilan method lain.
Dalam method d(). Sebelum operasi pembagian.
Exception in thread "main"
java.lang.ArithmeticException: / by zero
at
exception.Percobaan.d(MyException1.java:14)
at
exception.Percobaan.c(MyException1.java:22)
at
exception.Percobaan.b(MyException1.java:30)
at
exception.Percobaan.a(MyException1.java:38)
at
exception.MyException1.main(MyException1.java:6)
|
TRY
1.try dipergunakan untuk menempatkan blok
kode dimana ada kemungkinan exception terjadi dalam blok tersebut.
2.Bila exception terjadi dalam baris x dari
blok try, maka baris x+1 tidak
akan dijalankan
Contoh :
|
Bila exception terjadi pada baris ke 4
(statement2), maka baris ke 5 tidak akan dijalankan.
· Bila
dalam blok try tidak terjadi exception, kontrol
program akan meloncat ke blok finally (bila ada blok finally), dan kemudian kontrol program
akan meloncat ke statement setelah blok try-catch-finally [1&2].
Contoh:
|
1. ......
2. try {
3. statement1;
4. statement2;
5. statement3;
6. }
7. catch (ExceptionA
ea) {
8. ......
9. ......
10.}
11.catch
(ExceptionB eb) {
12.
......
13.
......
14.}
15.finally {
16.
.....
17.
.....
18.}
19.......
|
Bila dalam blok try tidak
terdapat exception (baris 5 sukses dijalankan), maka kontrol program akan
meloncat ke baris 16 dan 17 (bila terdapat blokfinally), dan kemudian kontrol
program meloncat ke baris 19.
CATCH
· Blok catch yang mengikuti blok try adalah
bersifat optional (bila setelah blok try tidak terdapat blok catch, maka setelah blok try harus
terdapat blokfinally).
· Sebuah
blok try dapat diikuti oleh 1 atau lebih blok catch.
· Bila ada
exception P dalam blok try, maka hanya blok catch yang bertanggung jawab untuk
menghandle exception P tersebut yang akan dijalankan. Bila ternyata tidak ada blok catch yang diperuntukkan menangkap exception P, maka exception akan dilempar ke
method pamanggil method ini.
Contoh: Lihat program 05 di atas J
· Blok catch yang diperuntukkan menangkap ExceptionA dapat pula menangkap exception bertipe
subclass dari Exception.
Contoh,
bila terdapat pohon inheritance dari exception sbb:
 |
Maka :
|
Blok catch
|
Jenis
exception yang dapat ditangkap
|
|
catch(ExceptionB
eb) {/*..*/}
|
ExceptionB
|
|
catch(ExceptionA
ea) {/*..*/}
|
ExceptionB dan ExceptionA
|
|
catch(Exception
e) {/*..*/}
|
ExceptionB, ExceptionA, danjava.lang.Exception
|
· Bila blok catch terdapat lebih dari 1, maka urutan
penempatan blok catch harus memenuhi aturan sebagai berikut .
1. Bila dalam blok-blok catch tersebut terdapat 2 atau lebih
exception yang terletak dalam sebuah pohon inheritance, maka blok catch pertama untuk pohon inheritance
tersebut adalah blok catch untuk menangkap jenis exception yang
paling khusus (exception yang terletak paling bawah dalam pohon inheritance).
2. Bila blok-blok catch menangkap exception yang saling
”sibling”(tidak terletak dalam 1 pohon inheritance), maka urutan penempatan
blok catch tidak menjadi masalah.
Contoh, bila terdapat pohon inheritance sbb [1]:
 |
|
PENEMPATAN URUTAN BLOK CATCH YANG VALID
|
PENEMPATAN URUTAN BLOK CATCH YANG TIDAK VALID
|
|
catch(ExceptionB
eb) {/*...*/}
catch(ExceptionA
ea) {/*...*/}
catch(ExceptionC
ec) {/*...*/}
|
catch(ExceptionA
ea) {/*...*/}
catch(ExceptionB
eb) {/*...*/}
catch(ExceptionC
ec) {/*...*/}
|
|
catch(ExceptionC
ec) {/*...*/}
catch(ExceptionB
eb) {/*...*/}
catch(ExceptionA ea) {/*...*/}
|
catch(ExceptionC
ec) {/*...*/}
catch(ExceptionA
ea) {/*...*/}
catch(ExceptionB
eb) {/*...*/}
|
|
catch(ExceptionB
eb) {/*...*/}
catch(ExceptionC
ec) {/*...*/}
catch(ExceptionA ea) {/*...*/}
|
catch(ExceptionA
ea) {/*...*/}
catch(ExceptionC
ec) {/*...*/}
catch(ExceptionB eb) {/*...*/}
|
Bila penempatan urutan catch tidak valid, maka program tidak dapat
dicompile (compile time error).
Contoh:
|
Program 07
|
|
class
ExceptionA extends Exception {}
public
class MyCatch3 {
private void throwException() throws ExceptionA {
throw new ExceptionA();
}
public static void main(String[] args) {
MyCatch3 obj = new MyCatch3();
try {
obj.throwException();
}
catch(Exception e) {}
catch(ExceptionA ea) {}
}
}
|
|
Program
di atas akan menghasilkan compile time error sbb :
E:\Data\Data
NetBeans\scjp\src\exception\MyCatch3.java:17: exception exception.ExceptionA
has already been caught
catch(ExceptionA ea) {}
1 error
|
· Bila
exception yang terjadi dalam blok try tidak dapat ditangkap oleh satupun
blok catch yang ada, maka exception akan dilempar
ke method pemanggil method saat ini (yang sesuai dengan method call stack).
· Bila dirangkum tentang semua mekanisme catch di atas, maka semua mekanisme itu
disebut dengan excpetion
matching : ”Bila dalam
blok try terjadi exception, maka akan dicari
blok catch yang dikhususkan menangkap exception
tersebut. Bila tidak ada, maka dicari blok catch yang dapat menangkap superclass dari
exception tersebut. Bila tetap tidak ada, maka exception akan dilempar ke
method pamanggil method saat ini”.
FINALLY
· Blok try dapat
diikuti oleh maksimal 1 buah blok finally (bila setelah blok try tidak
terdapat blok finally, maka
setelah blok try harus terdapat minimal 1 buah blok catch) [1].
· Blok finally harus terletak setelah blok-blok catch(bila ada), atau langsung
mengikuti blok try (bila blok catch tidak ada) [1].
· Blok finally pasti dijalankan, baik apabila pada
blok try terdapat exception ataupun tidak [1].
· Biasanya
blok finally berisi statement-statement untuk
cleanup resource [1&2].
· Skenario
umum yang melibatkan blok finally:
1. Bila dalam blok try tidak terdapat exception, maka setelah
blok try selesai dieksekusi, control flow akan
meloncat ke blok finally , dan blokfinally tersebut akan dijalankan. Setelah
blok finally dijalankan, control flow akan meloncat
ke statement setelah blok finally.
2. Bila dalam
blok try terdapat exception, maka control flow
program akan meloncat ke blok catch yang sesuai dengan exception tersebut
(bila ada), setelah blok catch selesai dijalankan, control flow akan
meloncat ke blok finally. Setelah
blok finally dijalankan, control flow akan meloncat
ke statement setelah blok finally.
3. Bila dalam
blok try terdapat exception, dan tidak terdapat catch yang sesuai untuk exception tersebut,
maka control flow akan meloncat ke blokfinally, setelah blok finally selesai dijalankan, flow control akan
meloncat lagi ke method pemanggil method saat ini. Bila dalam blok try terdapat statement return, blok finally tetap akan dijalan. Blok finally ini akan dijalankan tepat setelah
statement returndijalankan, dan
sebelum return mengembalikan nilai [1&2].
Contoh.
|
Program
08
|
|
public
class MyReturn1 {
public static void main(String[] args) {
MyReturn1 obj = new MyReturn1();
System.out.println("sebelum pemanggilan method a()");
obj.a();
System.out.println("setelah pemanggilan method a()");
}
public int a() {
try {
System.out.println("di dalam blok try");
return b(); //method b() adalah statement return.
} finally {
System.out.println("di dalam blok finally");
}
}
public
int b() {
System.out.println("di dalam method b()");
return 1;
}
}
|
|
Program di atas akan menghasilkan :
sebelum pemanggilan method a()
di dalam blok try
di dalam method b()
di dalam blok finally
setelah pemanggilan method a()
|
Pengertian ”Blok finally ini akan dijalankan tepat setelah
statement return dijalankan, dan sebelum return mengembalikan nilai” mungkin agak
membingungkan. Dari contoh program di atas, method b() adalah statement return (blok finally akan dijalankan setelah statement returndijalankan). Sedangkan
pengertian “return mengembalikan
nilai” adalah saat return mengembalikan nilai 1 hasil dari
statement return, Bila dalam blok catch yang sesuai dengan exception terdapat
keyword throw, blok finally tetap akan dijalan. Blok finally ini akan dijalankan tepat sebelum
keyword throw melemparkan exception.
Contoh:
|
Program
9
|
|
public
class MyFinally1 {
private static void pelemparException1()
throws Exception {
throw new Exception();
}
private
static void pelemparException2()
throws Exception {
try {
pelemparException1();
}
catch(Exception e) {
System.out.println("Dalam blok catch " +
"method pelemparException2()");
throw e;
}
finally {
System.out.println("Dalam blok finally " +
"method
pelemparException2()");
}
}
public static void main(String[] args) {
try {
pelemparException2();
}
catch(Exception e) {}
}
}
|
|
Program di atas akan menghasilkan :
Dalam blok catch method pelemparException2()
Dalam blok finally method pelemparException2()
|
CHECKED EXCEPTION
Yang termasuk checked exception adalah class java.lang.Throwable dan semua subclassnya, kecuali class
dan subclass dari java.lang.Error danjava.lang.RuntimeError. Bila terdapat checked exception, maka checked exception tersebut harus di
handle or declare [2].
Pengertian di handle adalah terdapat blok catchyang
sesuai dengan exception. [1] Pengertian di declare adalah
meletakkan daftar exception yang mungkin dilemparkan dari suatu method (dengan
keywordthrows).
Perhatikan contoh berikut:
|
Program
9
|
|
public class Coba1 {
public static void myMethod()
throws MyException, MyException2 {}
public static void myMethod2() {
try {
myMethod();
}
catch(MyException e) {}
}
}
class MyException extends Exception {}
class MyException2
extends Exception {}
|
|
Bila dicompile, program tersebut akan menghasilkan
error sbb:
E:\Data\Data NetBeans\scjp\src\exception\Coba1.java:7:
unreported exception exception.MyException2; must be caught or declared to be
thrown
myMethod();
1 error
|
Compile time error di atas terjadi karena myMethod() memiliki kemungkinan melemparkan
exception MyException dan MyException2. Akan
tetapi, dalam method myMethod2() yang memanggil myMethod() hanya memperhatikan exception MyException (myException2 tidak diperhatikan, dan menimbulkan
compile time error). Hal ini dapat diperbaiki dengan salah satu
dari 2 cara berikut:
1. Meng-catch exception MyException2
2. Mendeklarasikan bahwa method myMethod2() dapat melempar exception MyException2.
|
Program 10 (cara 1)
|
|
public
class Coba1 {
public static void myMethod()
throws MyException, MyException2 {}
public static void myMethod2() {
try {
myMethod();
}
catch(MyException e) {}
catch(MyException2 e) {}
}
}
class
MyException extends Exception {}
class
MyException2 extends Exception {}
|
|
Program x10(cara 2)
|
|
public
class Coba1 {
public static void myMethod()
throws MyException, MyException2 {}
public static void myMethod2() throws
MyException2 {
try {
myMethod();
} catch(MyException e) {}
}
}
class
MyException extends Exception {}
class
MyException2 extends Exception {}
|
· Suatu method yang memiliki keyword
throws dalam deklarasi methodnya, maka method itu memiliki kemungkinan untuk melempar jenis-jenis exception
yang ada setelah keyword throws. Pengertian kemungkinan disini adalah mungkin
melempar atau mungkin tidak melempar exception, jadi tidak selalu method dengan
keyword throws pasti melempar exception [1&2].
UNCHECKED EXCEPTION
· Unchecked exception adalah exception
yang tidak perlu diperhatikan oleh programmer (tidak akan
menimbulkan compile time error bila tidak diperhatikan).
Yang termasuk unchecked exception adalah kelas-kelas berikut :
1. java.lang.Error dan subclassnya
2. java.lang.RuntimeException dan subclassnya.
· Unchecked
exception tidak perlu di handle (catch) or declare (throws). Akan tetapi bila kita ingin menghandle ataupun
mengdeclarenya tidak masalah.
|
Program 11
|
|
package
exception;
public
class Coba2 {
public static void lemparException()
throws MyRuntimeException {
throw new MyRuntimeException();
}
//tanpa handle dan tanpa declare
public static void myMethod1() {
lemparException();
}
//dengan handle dan tanpa declare
public static void myMethod2() {
try {
lemparException();
}
catch(MyRuntimeException e) {}
}
//tanpa handle dan dengan declare
public static void myMethod3() throws
RuntimeException {
lemparException();
}
}
class
MyRuntimeException extends RuntimeException {}
|
COMMONS EXCEPTIONS AND ERRORS
· Subbab ini membahas exception dan errrors
yang sering keluar dalam ujian SCJP 1.5.
· Berikut ini adalah class diagram dari
kelas-kelas Exception dan Error yang sering keluar dalam ujian SCJP 1.5 [1]. Kelas-kelas yang
diarsir adalah yang sering keluar. Sebagai catatan, semua kelas dibawah ini
terletak pada package java.lang [1]
