Home
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 :
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 :
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 {
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>>
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
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.EXCEPTION
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
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(), maka method call
stack dapat digambarkan sebagai berikut [1&2]:
Method
yang paling atas dari stack (method c() dalam hal ini) adalah method yang saat
ini sedang dijalankan. Bila method c() telah selesai dijalankan, maka method
call stack dapat digambarkan sebagai berikut [1&2]:
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
Tidak ada komentar:
Posting Komentar