KATA PENGANTAR

Puji syukur atas ke hadirat Allah SWT, karena berkat rahmat-Nya penulis
dapat menyelesaikan makalah yang berjudul Interface dan Exception. Makalah ini
diajukan guna memenuhi tugas mata kuliah Pemograman Berbasis Objek.
Penulis mengucapkan terima kasih kepada semua pihak yang telah
membantu sehingga makalah ini dapat diselesaikan sesuai dengan waktunya.
Makalah ini masih jauh dari sempurna, oleh karena itu saya mengharapkan kritik
dan saran yang bersifat membangun demi kesempurnaan makalah ini.
Semoga makalah ini memberikan informasi bagi mahasiswa lainnya
khususnya mahasiswa Politeknik Negeri Lhokseumawe dan bermanfaat untuk
pengembangan ilmu pengetahuan bagi kita semua dan terutama bagi penulis
sendiri.
Demikian makalah ini saya buat semoga bermanfaat untuk para pembaca.
Buket Rata, 12 Desember 2015

Tim Penulis

DAFTAR ISI
KATA PENGANTAR...............................................................................................i
DAFTAR ISI............................................................................................................ii
BAB I PENDAHULUAN........................................................................................1
1.1.

Latar Belakang..........................................................................................1

1.1.1. Interface.................................................................................................1
1.1.2. Exception...............................................................................................1
BAB II PEMBAHASAN.........................................................................................3
2.1.

Paket pada Java..........................................................................................3

2.1.1. Tingkat Akses.........................................................................................5

2.2.

Konsep Interface........................................................................................9

2.1.1. Pelaksanaan..........................................................................................10
2.3. Interface Lanjutan.......................................................................................12
2.2.1.
2.3.

Pelaksanaan......................................................................................14

Exception.................................................................................................16

2.3.1 Pelaksanaan...........................................................................................18
2.4.

Exception Throw dan Throws.................................................................20

2.4.1 Pelaksanaan...........................................................................................21
2.5.

Membuat Class Ekpresi sendiri...............................................................22

2.5.1 Pelaksanaan...........................................................................................23
BAB III PENUTUP...............................................................................................25
3.1

Kesimpulan..............................................................................................25

DAFTAR PUSTAKA.............................................................................................26

ii

BAB I
PENDAHULUAN
1.1.

Latar Belakang

1.1.1. Interface
Pada proses pengembangan sistem sering kali kita dihadapkan kepada
berbagai ragam teknologi atau berbagai jenis teknik pembuatan program.
Misalnya dalam membuat aplikasi kita menggunakan berbagai jenis apliaksi
database dengan gaya pemrograman yang berbeda. Java memberikan fasilitas
untuk menjembatani perbedaan tersebut dengan apa yang disebut dengan
interface. Interface lebih mempermudah analyst dalam membuat konsep aplikasi,
interface mirip dengan pola atau biasa disebut dengan cetak biru aplikasi.
Apabila sbuah class java menggunakan interface maka class tersebut
mngimplementasikan interface. Pada saat class mengimplementasikan interface
walaupun semua yang ada di interface harus dicantumkan, namun tidak semuanya
harus berisi perintah atau proses. deklarasi interface harus public, karena memang
fungsi class pengguna interface adalah untuk digunakan secara public
Interface dalam kehidupan sehari-hari ibarat sebuah clausul kontrak, yang
berisi pasal-pasal, namun pasal-pasal tersebut masih kosong dan akan di isi pada
saat kontrak tersebut digunakan.
1.1.2. Exception
Dalam pembuatan program seringkali dijumpai error atau kesalahan. Oleh
karena itu, diperlukan suatu mekanisme yang membantu menangani error atau
kesalahan yang terjadi, baik saat pembuatan maupun implementasi program. Java
menyediakan mekanisme dalam pemrograman untuk menangani hal-hal tersebut
yang disebut dengan exception.

Exception adalah event yang terjadi ketika program menemui kesalahan

pada saat instruksi program dijalankan. Banyak hal yang dapat menimbulkan
event ini, misalnya crash, harddisk rusak dengan tiba-tiba, sehingga programprogram tidak bisa mengakses file-file tertentu.
Ada lima kata kunci yang digunakan oleh Java untuk menanngani
exception ini, yaitu, try, catch, finally, throw, dan throws.

BAB II
PEMBAHASAN
2.1.

Paket pada Java

Sebuah paket Java adalah mekanisme untuk mengatur Java kelas ke ruang

nama mirip dengan modul Modula . Paket-paket Java dapat disimpan dalam file
yang dikompresi dan disebut file JAR , memungkinkan kelas untuk mendownload lebih cepat sebagai kelompok daripada satu per satu. Programmer juga
biasanya menggunakan paket untuk mengatur kelas yang termasuk kategori yang
sama atau menyediakan fungsi serupa.
1. Sebuah paket menyediakan namespace yang unik untuk jenis yang
dikandungnya.
2. Kelas dalam paket yang sama dapat mengakses anggota-paket akses
masing-masing.
Java class library (Java API) memiliki banyak sekali kelas (Java
predefined classes) yang diletakkan ke dalam paket (package) untuk dapat
dipergunakan kembali di dalam program. Paket tersebut digunakan untuk
mengelompokkan kelas-kelas yang mempunyai kemiripan fungsi (related class).
Kelas-kelas Java yang akan digunakan di dalam program, terlebih dahulu harus
diimpor beserta dengan nama paket di mana kelas tersebut berada, kecuali untuk
kelas Java yang berada di paket java.lang seperti kelas JOptionPane yang berada
di paket javax.swing dan kelas DecimalFormat yang berada di paket java.text.
Berikut ini adalah daftar beberapa paket Java yang sering dipergunakan di dalam
kode program Java.

java.lang
java.util
java.io
java.math
java.nio
java.net
java.security
java.sql
java.awt
javax.swing
komponen
java.applet
The java.lang

- Fungsi dasar bahasa dan jenis dasar

- Pengumpulan Data struktur kelas
- Operasi file
- Multiprecision aritmatika
- Yang baru I / O kerangka untuk Java
- Operasi jaringan, soket, lookup DNS , ...
- Pembangkitan kunci, enkripsi dan dekripsi
- Java Database Connectivity (JDBC) untuk mengakses database
- Hirarki dasar paket untuk komponen asli GUI
- Hirarki paket untuk platform-independen yang kaya GUI
- Kelas untuk membuat applet
- paket tersedia tanpa menggunakan pernyataan impor.

Sebuah paket (package) sebenarnya adalah direktori yang digunakan untuk

menyimpan file-file bytecode (file berekstensi .class). Paket Java disusun secara
berjenjang (hierarchical). Anda bisa mempunyai paket di dalam paket yang lain.
Sebagai contoh, javax.swing.JOptionPane menunjukkan bahwa kelas JOptionPane
berada di dalam paket swing, dan paket swing itu sendiri berada di dalam paket
javax. Level jenjang paket dapat digunakan untuk memastikan keunikan dari
nama paket.

Semua kelas yang dibuat akan tersimpan di direktori yang sekarang aktif (current
directory atau default package) ketika program sumber Java dikompilasi. Karena
program sumber Java terletak di direktori, misalnya c:\hindro\javasc dan proses
kompilasi juga dilakukan di direktori tersebut, maka file bytecode hasil kompilasi
juga akan tersimpan di direktori yang sama.
2.1.1. Tingkat Akses
1. Tingkat Akses Private
Dengan menggukanan data dan method dengan tingkat akses private,maka
data dan method tersebut hanya dapat di akses oleh kelas yang di milikinya saja.
Modifier private, menunjukkan bahwa suatu class, method atau variabel hanya
dapat diakses dari dalam kelas tersebut. modifier ini biasanya digunakan untuk
kelas, method, atau variabel yang memang ingin disimpan atau tidak dapat
digunakan oleh kelas yang lain (tidak berguna untuk kelas yang lain).
Keyword Private
Ini adalah file privateClass.java
package satu;
public class privateClass{
private static int kuadrat(int bilangan){
return bilangan*bilangan;
}
}
class pengakses{
public static void main (String[] args) {
privateClass a=new privateClass();
System.out.println (Hasil 3 kuadrat = +a.kuadrat(3));
}
}

Begitu dicompile, maka akan keluar pesan kesalahan:

kuadrat(int) has private access in satu.privateClass

Ini adalah file pengakses1 yang terletak di package yang berbeda tetapi
merupakan subclass atau anak kelas dari privateClass.
package dua;

import satu.privateClass;
public class pengakses1 extends satu.privateClass{
static privateClass a=new privateClass();
public static void main (String[] args) {
System.out.println (Hasil dari 9 kuadrat adalah +a.kuadrat(9));
}
}

Begitu dicompile, akan keluar kode kesalahan:

kuadrat(int) has private access in satu.privateClass

Ini adalah file pengakses2 yang terletak pada package yang berbeda tapi bukan
termasuk anak kelas dari privateClass.
package dua;
import satu.privateClass;
public class pengakses2 {
static privateClass a=new privateClass();
public static void main (String[] args) {
System.out.println (a.kuadrat(9)); //kuadrat(int) has protected access in
satu.privateClass
}
}

Begitu dicompile, akan keluar pesan kesalahan:

kuadrat(int) has private access in satu.privateClass

2. Tingkat Akses Protect

Suatu data atau method yang di deklarasi kan dengan tingkat akses
protected dapat di akses oleh kelas yang di milikinya saja dan juga kelas-kelas
yang masih memiliki keturunan. Modifier protected, digunakan kalau suatu class,
method atau variabel ingin digunakan hanya oleh kelas-kelas yang satu paket
dengan kelas tersebut atau sub kelas dari kelas tersebut baik yang satu paket atau
lain paket.
Keyword Protected
Ini adalah isi file protectedClass.java
package satu;
public class protectedClass{
protected static int kuadrat(int bilangan){
return bilangan*bilangan;

}
}
class pengakses{
public static void main (String[] args) {
protectedClass a=new protectedClass();
System.out.println (Hasil 3 kuadrat = +a.kuadrat(3));
}
}

Output dari program di atas adalah:

Hasil dari 9 kuadrat adalah 81
Ini adalah isi file pengakses1 yang terletak pada package yang berbeda tetapi
merupakah subclass dari class protectedClass. Pada proses compile tidak akan
terjadi proses kesalahan.
package dua;
import satu.protectedClass;
public class pengakses1 extends satu.protectedClass{
static protectedClass a=new protectedClass();
public static void main (String[] args) {
System.out.println (Hasil dari 9 kuadrat adalah +a.kuadrat(9));
}
}

Output dari program di atas adalah:

Hasil dari 9 kuadrat adalah 81

Di bawah ini adalah isi file pengakses2 yang terletak pada package yang berbeda
dan bukan subclass dari class protectedClass.
package dua;
import satu.protectedClass;
public class pengakses2 {
static protectedClass a=new protectedClass();
public static void main (String[] args) {
System.out.println (a.kuadrat(9)); //error
}
}

Jika program dicompile, maka akan muncul pesan kesalahan:

kuadrat(int) has protected access in satu.protectedClass

3. Tingkat Akses Public
Tingkatan public merupakan kebalikan dari tingkat akses private.data
maupun method dapat di akses oleh semua bagian di dalam program. Modifier
public akan membuat class, method, variabel yang menggunakanya bersifat
umum, alias dapat dipanggil oleh semua kelas. baik dari satu paket yang sama
atau berlainan paket. public juga akan memperbolehkan akses terhadap semua
kelas yang diinstan dari kelas tersebut
Keyword Public
package satu;
public class publicClass{
public static int kuadrat(int bilangan){
return bilangan*bilangan;
}
}
class pengakses{
public static void main (String[] args) {
publicClass a=new publicClass();
System.out.println (Hasil dari 9 kuadrat adalah +a.kuadrat(9));
}
}

Begitu dijalankan, outputnya adalah

Hasil dari 9 kuadrat adalah 81
package dua;
import satu.publicClass;
public class pengakses1 extends satu.publicClass{
static publicClass a=new publicClass();
public static void main (String[] args) {
System.out.println (Hasil dari 9 kuadrat adalah +a.kuadrat(9));
}
}

Begitu dijalankan, outputnya adalah

Hasil dari 9 kuadrat adalah 81
package dua;
import satu.publicClass;

public class pengakses2 {

static publicClass a=new publicClass();
public static void main (String[] args) {
System.out.println (Hasil dari 9 kuadrat adalah +a.kuadrat(9));
}
}

Begitu dijalankan, outputnya adalah

Hasil dari 9 kuadrat adalah 81

2.2. Konsep Interface

Interface adalah kelas yang benar-benar abstrak, artinya hanya berisi
deklarasi method dan (jika ada) konstanta saja. Method-method tersebut nantinya
harus diimplementasikan pada real class. Interface dapat dianalogikan seperti
menandatangani kontrak kerja. Misalnya seorang dosen wajib mengajar, membuat
soal, dsb, akan tetapi cara mengajar dan membuat soalnya diserahkan ke masingmasing dosen (tidak ditentukan dalam kontrak kerja).
Interface mendefinisikan suatu protokol perilaku tanpa dipusingkan
dengan implementasinya. Suatu kelas yang mengimplementasikan interface maka
pada kelas tersebut akan melekat perilaku yang didefinisikan interface.
Sebagai contoh : Dalam kehidupan nyata dapat diketahui ada manusia
yang bekerja sebagai tentara, penyanyi, pengacara, dan sebagainya, tentunya
manusia-manusia tersebut selain harus memiliki method standard sebagai seorang
manusia, juga harus memiliki method yang sesuai dengan pekerjaannya. Dengan
demikian untuk membuat objek manusia yang bekerja sebagai penyanyi, harus
dibuat kelas yang merupakan turunan kelas manusia yang meng-implementasikan
interface penyanyi.
Deklarasi interface :
[modifier] interface NamaInterface {
deklarasi konstanta;
deklarasi method-method;
}
Implementasi kemudian dilakukan pada class lainnya:

[modifier] class NamaKelas implements NamaInterface{

definisi method-method;

2.1.1. Pelaksanaan
Praktek 1 : Interface ActionListener
Coba dan pelajari contoh penggunaan interface dalam aplikasi GUI berikut.
Dalam contoh ini Kelas Tombol diturunkan dari kelas Frame, dan juga
mengimplementasikan interface ActionListener, yang memiliki sebuah method
yaitu : ActionPerformed.
import java.awt.*;
import java.awt.event.*;
public
class
Tombol
extends
Frame
implements
ActionListener {
//dekarasi komponen
Button bTekan = new Button();
TextField txt1 = new TextField("
");
public Tombol() {
//layout komponen
this.setLayout(new FlowLayout());
//menambahkan komponen ke frame
this.add(bTekan,null);
this.add(txt1,null);
//menulis text ke button
bTekan.setLabel("Tekan Aku");
//menambahkan action listener ke komponen
bTekan.addActionListener(this);
}
//implementasi method ActionPerformed
public void actionPerformed(ActionEvent e){
Object cmd = e.getSource();
if (cmd.equals(bTekan))
txt1.setText("Halo Semua");
}
public static void main(String[] argv){

10

Tombol tmbl = new Tombol();

tmbl.pack();
tmbl.setTitle("Tombol AWT");
tmbl.setVisible(true);
}
}
Praktek 2 : Interface Bangun2D
Interface

Bangun2D

hitung_Keliling().

memiliki

method,

yaitu

hitung_Luas()

dan

Kelas Lingkaran yang mengimplementasikan interface

Bangun2D harus membuat definisi untuk kedua method tersebut.

<<Bangun2D>>
+hitung_luas();
+hitung_Keliling();

Lingkaran
-daftar field
+daftar method

interface Bangun2D{
public double hitung_Luas();
public double hitung_Keliling();
}
class Lingkaran implements Bangun2D{
private double jejari;
public void setJejari(double jejari){
this.jejari=jejari;
}
public double getJejari(){

11

return this.jejari;
}
public double hitung_Luas(){
return (3.14 * this.jejari * this.jejari);
}
public double hitung_Keliling(){
return (2 * 3.14 * this.jejari);
}
}
class TestLingkaran{
public static void main(String[] arg){
Lingkaran bunder = new Lingkaran();
bunder.setJejari(10);
double luas = bunder.hitung_Luas();
double keliling = bunder.hitung_Keliling();
System.out.println("Luas lingkaran dengan jejari
"+bunder.getJejari()+ " adalah "+luas);
System.out.println("Keliling lingkaran dengan jejari
"+bunder.getJejari()+" adalah "+keliling);
}
}

2.3. Interface Lanjutan

Pewarisan merupakan proses penurunan field dan method dari suatu
kelas induk kepada satu/lebih subkelas. Seringkali dibutuhkan suatu kelas yang
field dan methodnya berasal dari lebih dari satu kelas induk (pewarisan jamak).
Pewarisan jamak memang mempercepat dalam pembuatan kelas. Tetapi
mempunyai beberapa kelemahan diantaranya adalah terjadi ambiguitas karena
adanya method yang sama yang diturunkan dari beberapa kelas induk.
Java tidak mengijinkan pewarisan jamak. Sebagai gantinya java
menggunakan interface. Terdapat 2 jenis penyelesaian masalah pewarisan jamak
di java, yaitu :
1. Kombinasi antara turunan satu kelas dan interface

12

[modifier]

class

NamaKelas

extends

NamaKelasInduk

implements NamaInterface {
//isi kelas
}

2. Dengan implementasi multiple interface

[modifier]

class

NamaKelas

implements

NamaInterface1,

NamaInterface2, {
//isi kelas
}

Suatu Interface dapat diperluas menjadi Interface baru yang lebih lengkap.
[modifier] interface NamaInterface2 extends NamaInterface1{
//daftar konstanta dan method
}

2.2.1. Pelaksanaan

13

Praktek 1 : Kombinasi antara turunan satu kelas dan interface

interface MProvides{
void func();
}

interface MRequires{
int getValue();
}
class Mixin implements MProvides
{
private final MRequires parent;
public Mixin(MRequires parent) {
this.parent = parent;
}
public void func() {
System.out.println("Nilai dari method func: " +
parent.getValue());
}
}
class Parent
{
private int value;
public Parent(int value ) {
this.value = value;
}
public int getValue() {
return this.value;
}
}
class Child extends Parent implements MRequires, MProvides{
private final MProvides mixin;
public Child(int value){
super(value);
this.mixin = new Mixin(this);
}
public void func(){
mixin.func();

14

}
}
class TestInherInterface{
public static void main(String[] arg){
Child anak = new Child(5);
anak.func();
System.out.println("nilai
getValue:"+anak.getValue());
}

dari

method

Praktek 2 : Multiple interface

interface Interface1 {
public void tampilInfo();
public void setInfo(String info);
}
interface Interface2 {
public void tampilInfo();
}
public class MultiInterfaces implements Interface1, Interface2 {
private String info;
public void setInfo(String info) {
this.info = info;
}
public void tampilInfo(){
System.out.println(this.info+": ini info dari method tampilInfo,
ndak error to");
}
public static void main(String[] a) {
MultiInterfaces t = new MultiInterfaces();
t.setInfo("Hai");
t.tampilInfo();
}
}

15

2.3. Exception
Dalam pembuatan program seringkali dijumpai error atau kesalahan. Oleh
karena itu, diperlukan suatu mekanisme yang membantu menangani error atau
kesalahan yang terjadi, baik saat pembuatan maupun implementasi program. Java
menyediakan mekanisme dalam pemrograman untuk menangani hal-hal tersebut
yang disebut dengan exception.
Exception adalah event yang terjadi ketika program menemui kesalahan
pada saat instruksi program dijalankan. Banyak hal yang dapat menimbulkan
event ini, misalnya crash, harddisk rusak dengan tiba-tiba, sehingga programprogram tidak bisa mengakses file-file tertentu. Programmer pun dapat
menimbulkan event ini, misalnya dengan melakukan pembagian dengan bilangan
nol, atau pengisian elemen array melebihi jumlah elemen array yang dialokasikan
dan sebagainya.
Exception terdiri dari dua macam kelompok, yaitu :

Exception yang merupakan subclass RunTimeException

Exception yang bukan subclass RunTimeException

RunTimeException biasanya disebabkan oleh kesalahan program atau pada desain

program. Misalnya NullPointerException yang disebabkan oleh proses inisialisasi
program yang tidak sempurna dan ArrayIndexOutOfBoundsException yang
disebabkan akses array yang melebihi kapasitas array yang ada.
Dalam bahasa Java, ketika terjadi kesalahan, otomatis akan dilemparkan
sebuah objek yang disebut exception, yang kemudian dapat diproses lebih lanjut
oleh fungsi-fungsi yang siap menangani kesalahan tersebut. Proses pelemparan
exception tersebut sering dikenal dengan istilah throwing exception, sedangkan
proses penerimaan exception yang bersangkutan dikenal dengan istilah catch
exception

16

Ada lima kata kunci yang digunakan oleh Java untuk menanngani
exception ini, yaitu, try, catch, finally, throw, dan throws.
Situasi yang menyebabkan exception dibagi menjadi 3 kategori yaitu,

Kesalahan kode atau data. Contohnya jika kode berusaha

mengakses suatu indeks dari array yang di luar batas array.

Metode standar exception. Contohnya, metode substring() dalam

kelas String, dapat memunculkan pesan dalam bentuk String Index Out
ofBoundsException.

Kesalahan

Java.

Hal

ini

merupakan

kesalahan

dalam

mengeksekusi Java Virtual Machine yang dijalankan pada saat kompilasi.

Istilah exception digunakan untuk menunjukkan kesalahan pada hardware,
software, serta algoritma. Suatu exception adalah obyek dari kelas standar
Throwable, yang mempunyai turunan terdiri dari :

Error.

Exception

yang

didefinisikan

dalam

keas

ini

mempunyai karakteristik bahwa kondisi yang terjadi tidak

dapat diubah. Terdapat tiga macam subclass yang berada
dibawahnya

yaitu,

ThreadDeath,

Linkage

Error,

VirtualMachineError.

Exception. Untuk kelas yang diturunkan dari exception

kompiler memeriksa bahwa kita bisa menangani exception
dengan metode yang ada.

Kelas exception mempunyai banyak kelas turunan. Dua kelas yang penting
yaitu,

IOException

RuntimeException

17

Tabel Subkelas dari RunTime Exception

Kelas
ArithmeticException
IndexOutofBoundsException
NegativeArraySizeException
NullPointerExcepotion
ArrayStroreException
ClassCastException
IllegalArrayArgumentException
SecurityException
IllegalMonitorStateException
IllegalStateException
UnsupportedOperationException

Keterangan
Kesalahan pada operasi aritmatika
Beberapa jenis indeks di luar batas
Array diciptakan dengan ukuran negatif
Penggunaan acuan null yang tidak valid
Penyimpanan array dengan tipe data yang
tidak sesuai.
Cast yang tidak valid
Argumen yang tidak benar
Aturan sekuriti yang dilanggar
Operasi monitor ilegal
Lingkungan yang tidak benar
Operasi yang tidak didukung

2.3.1 Pelaksanaan
Macam penanganan exception, exception menggunakan kata kunci try, catch, dan
finally sebagai berikut :

Kode yang akan dimonitor exception-nya diletakkan dalam blok try.

Jika terjadi exception dalam blok tersebut, maka exception dilemparkan.

Blok yang diawali dengan catch menangani exception tersebut.

Blok yang diawali dengan finally pada umumnya dieksekusi sebelum

methode berakhir.

Sintaks blok try .. catch adalah sebagai berikut :

try
{
//kode yang dapat memunculkan exception
}
catch
{
//kode untuk menangani exception
}

18

Sintaks blok try .. catch ..finally adalah sebagai berikut :

try
{
//kode yang dapat memunculkan exception
}
catch
{
//kode untuk menangani exception
}
finally
{
//blok kode yang selalu dieksekusi
}

Contoh program try-catch

public class TryCatch {
public static void main(String[] args) {
int i=1;
int j=0;
try
{
System.out.println("i="+i+"j="+j);
System.out.println(i/j);
System.out.println("Blok Terakhir dari try");
}
catch (ArithmeticException e){
System.out.println("Keterangan exception = "+e);
}
System.out.println("Setelah blok try");
return;
}
}

19

Contoh program try-catch-finally

public class TryFinal {
public TryFinal() {
}
public static void main(String[] args) {
int i=1;
int j=0;
try
{
System.out.println("i="+i+"j="+j);
System.out.println(i/j);
System.out.println("Blok Terakhir dari try");
}
//catch exception
catch (ArithmeticException e){
System.out.println("Keterangan exception = "+e);
}
finally{
System.out.println("Dieksekusi setelah Blok try");
}
}
}

2.4. Exception Throw dan Throws

Kata kunci throw digunakan di program untuk melempar (throw) exception
secara eksplisit. Bentuk umum kalimat adalah,
Throw ThrowableInstance;
Instan Throwable harus merupakan obyek dengan tipe Throwable atau subkelas
dari Throwable. Terdapat dua cara untuk memperoleh obyek Throwable, yaitu,
1. Menggunakan parameter di klausa catch
2. Menciptakab salah satu dengan menggunakan operator new()
Eksekusi program akan dihentikan segera setelah kalimat throw, kalimat-kalimat
setelah kalimat throw tidak dieksekusi. Java akan melakukan inspeksi blok try
terdekat untuk menemukan catch yang cocok dengan dengan tipe exception yang
dilempar. Jika Java menemukannya, maka kendali program ditransfer ke kalimat

20

itu. Jika tidak ditemukan, maka Java akan melakukan penelusuran ke blok
berikutnya dan bila tetap tidak ditemukan, maka penanganan exception secara
default akan menghentikan programnya.
Penggunaan kata kunci throws berhubungan erat dengan penggunaan
exception yang dicek oleh Java. Klausa throws mendaftarkan tipe-tipe exception
yang dapat dilempar method. Hal ini diperlukan agar diketahui semua exception
yang mungkin dilempar method atau subkelasnya, kecuali tipe Error atau
RunTimeException yang dilakukan sistem Java secara otomatis bila menemui
pelangggaran aturan-aturan Java. Semua exception yang hendak dilempar method
harus dideklarasikan di klausa throws. Jika method melemparkan exception yang
tidak dideklarasikan di deklarasi method, maka kompilator akan memberi pesan
kesalahan.
2.4.1 Pelaksanaan
Secara umum, penggunaan kata kunci throw, yaitu, Throw ObjekEksepsi;
ObjekEksepsi disini adalah semua obyek yang merupakan turunan dari class
throwable.
Contoh Program Menggunakan throw
public class DemoEksepsi {
public static void methodLain() {
try
{
throw new ArrayIndexOutOfBoundsException(1);
}
catch (ArrayIndexOutOfBoundsException e){
System.out.println("Penanganan

eksepsi

dalam

Method

MethodLain()");
throw e;
}
}
public static void main(String[]args) {
try
{
methodLain();

21

}
catch (ArrayIndexOutOfBoundsException e){
System.out.println("Penanganan eksepsi dalam Method main()");
}
}
}

Contoh Program Menggunakan throws

public class DemoEksepsi {
public static void methodLain()
throws java.rmi.ServerException,java.rmi.RemoteException
{
int i = 10;
if(i==10)
throw new java.rmi.ServerException(Eksepsi dalam method
MethodLain())
else
throw new java.rmi.RemoteException(Eksepsi lainnya dalam
MethodLain
}
}

2.5. Membuat Class Ekpresi sendiri

Meskipun tersedia banyak

kelas exception pada package java.lang,

namun tidak mencukupi untuk menampung seluruh kemungkinan tipe eksepsi

yang mungkin terjadi. Sehingga seringkali diperlukan untuk membuat tipe eksepsi
tersendiri.
Cara

pembauatan

kelas

eksepsi

baru

adalah

mudah.

Tinggal

mendefinisikan turunan kelas Exception (yang juga merupakan turunan dari kelas
Throwable). Kelas baru tersebut tidak perlu mengimplementasikan apapun. Hanya
perlu mendeklarasikan konstruktor yang mungkin akan digunakan.

22

Kelas Exception tidak mendefinisikan method apapun di dirinya. Kelas ini

hanya mewarisi method-method yang disediakan kelas Throwable. Jika
diperlukan, maka method-method tersebut dapat dioverride sesuai kebutuhan
Berikut ini daftar method tersebut :
Method
Throwable fillStackTrace()

Fungsi
Mengembalikan object

String getLocalizedMessage()

yang berisi data stack trace lengkap.

Mengembalikan deskripsi tentang

String getMessage()

eksepsi menggunakan bahasa lokal

Mengembalikan deskripsi tentang

void printStackTrace()
void printStackTrace(PrintStream

eksepsi
Menampilkan stack trace
Mengirim hasil dari stack trace ke

Throwable

stream)
stream yang telah ditentukan
void printStackTrace(PrintWriter stream) Mengirim hasil dari stack trace ke
String toString()

stream yang telah ditentukan

Mengembalikan deskripsi tetang tipe
object eksepsi dan penjelasan tentang
eksepsi

tersebut.

Akan

dipanggil

secara otomatis ketika object eksepsi

dicetak dengan method println()

2.5.1 Pelaksanaan
Contoh Program Membuat Exception
class EksepsiKu extends Exception{
EksepsiKu(String s){
super(s);
}
}
class TestEksepsiKu {
public static void methodKu() throws EksepsiKu {
throw new EksepsiKu("Isi Eksepsi");
}

23

public static void main(String[] args) {

try {
methodKu();
} catch (EksepsiKu e) {
System.out.println("Terjadi eksepsi: dari " + e);
}
}
}

Contoh Program membuat Ekpresi

class StringException extends RuntimeException{
/* Tidak perlu memasukkan member ataupun construktor */
}
class TestStringException {
public static void main(String args[]) {
String input = "invalid input";
try {
if (input.equals("invalid input")) {
throw new StringException();
}
System.out.println("String accepted.");
} catch (StringException e) {
System.out.println("I hate this string: " + input
+".");
}
}

24

BAB III
PENUTUP
3.1 Kesimpulan
Interface adalah kelas yang benar-benar abstrak, artinya hanya berisi
deklarasi method dan (jika ada) konstanta saja. Method-method tersebut nantinya
harus diimplementasikan pada real class.
Sedangkat Paket pada Java adalah mekanisme untuk mengatur Java kelas
ke ruang nama mirip dengan modul Modula . Paket-paket Java dapat disimpan
dalam file yang dikompresi dan disebut file JAR , memungkinkan kelas untuk
men-download lebih cepat sebagai kelompok daripada satu per satu.
Exception adalah event yang terjadi ketika program menemui kesalahan
pada saat instruksi program dijalankan. Banyak hal yang dapat menimbulkan
event ini, misalnya crash, harddisk rusak dengan tiba-tiba, sehingga programprogram tidak bisa mengakses file-file tertentu.
Ada lima kata kunci yang digunakan oleh Java untuk menanngani
exception ini, yaitu, try, catch, finally, throw, dan throws.

25

DAFTAR PUSTAKA
Wikipedia. 2013. Java. http://id.wikipedia.org/wiki/Java. 04-10-2013
Lyyrac. 2013. Belajar Java. http://java.lyracc.com/belajar/java-untuk-pemula. 0410-2013.
Uin-Malang. 2011. Fun with Java Language Programaing. http://blog.uinmalang.ac.id/funjava/. 04-10-2013
Rangsang Purnama, Tuntunan Pemrograman Java Jilid 3, Prestasi Pustaka,
Jakarta, 2005.
Sinaga B.L, Pemrograman Berorientasi Objek dengan Java, Gava Media,
Yogyakarta, 2004.

26