PEMROGRAMAN BERORIENTASI OBJEK
Belajar PBO, berarti harus membiasakan diri berpikir secara kelas dan objek setiap menghadapi masalah.
Contoh
:
Buatlah program untuk menghitung keliling lingkaran dari masukan
jari-jarinya !
Masalah tersebut bila disajikan dengan pendekatan kelas dan objek, harus
direvisi sebagai berikut :
Buatlah kelas lingkaran yang memiliki tanggungjawab mengetahui jari-jarinya
dan kelilingnya, lingkaran tersebut dapat melakukan aksi mengembang dan
berkerut sesuai dengan panjang jari-jarinya.
Sylabi
1.
Pengantar
2.
Kelas, Method dan Modifier
3.
Objek
4.
Package
5.
Information Hiding, Encapsulation, Inheritance, dan Polymophism
6.
Kelas Inner, Kelas Abstract, dan Interface
7.
Exception Handling
8.
Kelas-Kelas Dasar
9.
MultiThreading
BAB I. Pengantar
(Identifier, Keyword, Literal dan Tipe Data,
Operator, Separator)
1.1.
Pengantar
Bahasa java yang telah dirilis :
1.
Product Sun Microsystem : j2se, j2me, j2ee
2.
Product Borland : JBuilder
3.
Product Microsoft : Visual J
Spesifikasi j2ee antara lain JDBC, JDOM (untuk XML), Remote Method Invocation, Enterprise Java
Beans, Java Messaging, Java Server Pages, Java Servlet, Socket Programming, dan
SQLJ.
Java/Standard Development Kit (JDK/SDK) merupakan alat-alat utama bagi
programmer untuk membuat dan menjalankan java.
Development Kit dapat didownload di :
Komponen JDK antara lain compiler(javac), interpreter(java) disebut juga
java virtual machine atau java runtime environment, applet
viewer(appletviewer), debugger(jdb), java class library(jcl), header dan stub
generator(javah), dan yang paling penting yaitu java documentation(javadoc).
Penjelasan penggunaan komponen JDK :
1.
Kompilator (javac)
Bertugas untuk melaksanakan kompilasi
*.java menjadi *.class
Syntax umum : javac
nama.java
2. Interpreter (java)
Bertugas untuk menjalankan bytecode (*.class)
Syntax umum : java
nama.class
3.
Applet Viewer
Digunakan untuk menjalanakan applet viewer, namun sekarang
sudah digantikan browser.
Syntax umum : appletviewer
nama.html
3.
Java Debugger
Bertugas untuk melakukan debugging aplikasi java. Syntax umum : jdb option
4.
Java Class File Diassembler (javap)
Bertugas membuat daftar method dan attribute public dari suatu kelas.
Syntax : javap namaKelas
5.
Java Header and Stub Generator
Bertugas menerjemahkan bahasa yang ditulis dalam bahasa java menjadi
bahasa C.
Syntax umum : javah namaKelas
6.
Java Documentation Generator
Menampilkan pustaka kelas, interface, constructor, dan method standard
yang telah dibuat vendor.
Dari hasil instalasi, dokumentasi ini dapat dilihat di pada C:\java\docs\api\index.html atau
C:\Program Files\NetBeans3.6\docs\junit\index.html
7.
Source Code Java API
Source code ini dapat diperoleh dari file src.zip.
Untuk pemrogram pemula lingkungan pemrograman java dapat diringkas
menjadi :
1.
Editing source code menggunakan editor teks.
2.
Compiling
menggunakan keyword javac melalui
command promp (dapat juga dari editor teks).
3.
Executing
menggunakan :
a.
Keyword java
melalui command prompt (dapat juga dari editor teks)
b.
Browser atau applerviewer untuk applet.
Token
Token adalah elemen terkecil di program yang masih memiliki arti. Ada 5
token dalam bahasa java yaitu identifier, keyword, literal dan tipe data,
operator, serta separator.
Identifier
Identifier adalah token yang merepresentasikan nama sesuatu. Sesuatu
tersebut adalah variabel, atau konstanta, atau attribute, atau method, atau
kelas, atau package, atau interface, atau nama file, dan lain-lain.
Keyword
Kata kunci digunakan untuk suatu tujuan tertentu. Ada 51 keyword dalam
java yaitu :
|
abstract
|
continue
|
for
|
new
|
switch
|
|
boolean
|
default
|
goto
|
null
|
synchronized
|
|
break
|
do
|
if
|
package
|
this
|
|
byte
|
double
|
implements
|
private
|
threadsafe
|
|
byvalue
|
else
|
import
|
protected
|
throw
|
|
case
|
extends
|
instanceof
|
public
|
throws
|
|
catch
|
false
|
int
|
return
|
transient
|
|
car
|
final
|
interface
|
short
|
true
|
|
class
|
finally
|
long
|
static
|
try
|
|
const
|
float
|
native
|
super
|
void
|
|
|
|
|
|
while
|
Literal dan
Tipe Data Primitif
Literal adalah nilai variabel/attribute atau nilai konstanta atau nilai
objek data. Ada tiga besaran literal dalam java yaitu angka, karakter, dan
string.
Angka terdiri dari byte, short, int, long, float, double, dan boolean
(dianggap angka true = 1 atau false = 0)
Semua variabel dan konstanta yang
akan digunakan harus dipesan terlebih dahulu dalam deklarasi.
Bentuk umum :
TipeData namaVar = ungkapan_atau_nilai;
TipeData namaVar1, namaVar2, …;
[modifier] static final TipeData
NAMAKONSTANTA = nilai;
Contoh deklarasi :
double a=3, b=4;
double c = Math.sqrt(a*a+b*b);
static final PHI=3.14;
static final double CM_PER_INC =
2.54;
Berikut tabel jangkauan dan ukuran dari semua tipedata sederhana dalam
java :
|
Tipe Data Primitif
|
Jangkauan
|
Ukuran (bit)
|
|
byte
|
-128 s/d 127
|
8
|
|
short
|
-32767 s/d 32767
|
16
|
|
int
|
-2147483648 s/d
2147483647
|
32
|
|
long
|
-9223372036854775808
s/d
9223372036854775807
|
64
|
|
char
|
sebuah Unicode
|
16
|
|
float
|
3.4e-038 s/d
3.4e+038
|
32
|
|
double
|
1.7e-308 s/d
1.7e+308
|
54
|
|
boolean
|
false = 0 atau true
= 1
|
8
|
Operator
Operator melakukan komputasi terhadap satu/dua
objek data. Operan yang dioperasikan dapat berupa literal, variabel, atau nilai
yang dikirim method.
Berikut tabel dan hirarki operator :
|
Prioritas
|
Kelompok
Operator
|
Keterngan
|
|
1
|
.
[] ()
|
Sekaligus
|
|
2
|
++var,
--var, ~, instanceof
|
preincrement,
predecrement, unary, instance dari kelas …
|
|
3
|
(type)
(casting)
|
|
|
4
|
!
|
Not
|
|
5
|
*, /, %
|
perkalian,
pembagian, modulus
|
|
6
|
+, -
|
penjumlahan,
pengurangn
|
|
7
|
<<,
>>, >>>
|
geser
untuk bil biner
|
|
8
|
<,
>, <=, >=
|
pembandingan
|
|
9
|
==, !=
|
kesamaan,
ketidaksamaan
|
|
10
|
&
|
and
|
|
11
|
^
|
exclusive
or
|
|
12
|
|
|
unconditional
or
|
|
13
|
&&
|
conditional
and
|
|
14
|
||
|
conditional
or
|
|
15
|
? :
|
shorthand untuk
if..then…else…
|
|
16
|
=, +=,
-=, *=, /=, %=, ^=
|
operator
penugasan
|
|
17
|
&=,
|=, <<=, >>=, >>>=
|
operator
penugasan
|
|
18
|
var++,
var--
|
postincrement,
postdecrement
|
Separator
Separator menginformasikan ke compiler java mengenai adanya kelompok kode
program.
Berikut adalah daftar separator di java :
|
Notasi
|
Nama
|
Deskripsi
|
|
(…)
|
kurung
|
mengelompokkan parameter method.
|
|
{…}
|
kurung kurawal
|
mengelompokkan nilai-nilai suatu array,
mendefinisikan blok kode kelas ataupun kode method.
|
|
[…]
|
kurung siku
|
mendeklarasikan tipe array
|
|
:
|
titik koma
|
mengakhiri pernyataan, merangkai pernyataan-pernyataan di
dalam for.
|
|
,
|
koma
|
memisahkan identifier-identifier di bagian deklarsi
variable.
|
|
.
|
titik
|
memisahkan nama-nama package,
memisahkan kelas dari objek,
dan objek dari method.
|
Keyword
break, continue, dan return
Kelompok keyword ini pada prinsipnya merupakan kendali jump (variasi lain
dari goto), sehingga berakibat pengabaian sisa instruksi.
Penggunaan
keyword break
Ada dua penggunaan keyword break, yaitu untuk keluar dari kendali percabangan switch, dan untuk keluar dari kendali perulangan.
Dengan keyword ini berarti percabangan/perulangan akan diakhiri, kemudian
eksekusi dilanjutkan ke pernyataan setelah blok percabangan/perulangan
tersebut.
Contoh :
public class ContohBreak {
public static void
main(String args[]) {
int i = 0;
do {
i++;
System.out.println(i);
if (i==5) break;
} while (i <= 9);
}
}
Penggunaan
keyword continue
Penggunaan keyword ini untuk segera lompat ke perulangan berikutnya.
Pernyataan-pernyataan setelah keyword continue dalam blok perulangan saat itu
berarti diabaikan.
Contoh :
public class contohContinue {
public static void
main(String args[]) {
int i=0;
do {
i++;
if (i==3) continue;
System.out.println(”iterasi ke : “+i);
if (i==5) break;
} while(i <= 9);
}
}
Penggunaan
keyword return
Keyword ini digunakan untuk keluar
dari suatu method, pernyataan-pernyataan setelah keyword ini dan masih dalam
blok method tersebut, berarti diabaikan, kemudian eksekusi dilanjutkan ke
pernyataan setelah blok method tersebut.
Contoh cuplikan
program :
int abs(int x) {
if (x >= 0)
return x;
else
return(-x)
…
}
}
BAB
II. KELAS, METHOD, DAN MODIFIER
Apapun konsep yang diimplementasikan di java harus dikapsulkan ke dalam
kelas.
Kelas mendefinisikan sekumpulan objek yang memiliki kesamaan keadaan dan
perilaku.
Ada dua kelompok kelas, yaitu kelas standard dan kelas yang didefinisikan
sendiri. Kumpulan dari method/kelas standard dalam java dikenal dengan API
(Aplication Programming Interface).
2.1. Pengertian
Kelas
Kelas digunakan untuk membuat objek, dan
berperan sebagai tipe data dari objek. Kelas
merupakan sarana pengkapsulan kumpulan data dan kumpulan method yang
mengoperasikan kumpulan data tersebut.
2.2. Anatomi
Kelas
Bentuk umum struktur anatomi kelas sebagai berikut
(modifier1)
class NamaKelas (modifier2) {
classbody
}
Classbody terdiri dari attribute, constructor, dan method.
Modifier pada anatomi kelas, sifatnya optional, digunakan berdasarkan
kebutuhan. Modifier menunjukkan sifat-sifat tertentu dari : kelasnya,
methodnya, atau attributenya.
Ada 10 keyword yang digunakan sebagai modifier1 dan dikelompokkan menjadi
:
1.
Modifier akses (public,
protected, default, private)
2.
Modifier final
3.
Modifier static
4.
Modifier abstract
5.
Modifier synchronized
6.
Modifier native
7.
Modifier storage
(transient, volatile)
Modifier yang memiliki sifat saling kontradiktif yaitu static dan abstract. Sementara static
tidak boleh memberi sifat pada interface, dan keyword super tidak boleh digunakan pada method static.
Ada 2 keyword yang sering digunakan sebagai modifier2, yaitu extends dan implements.
2.3. Deklarai
Attribute (Variabel Anggota Data)
Deklarasi diletakkan di dalam classbody (di luar method). Bentuk umum
deklarasi attribute :
[modifier] tipedata namavariabel;
[public] [static] final tipedata
NAMA_KONSTANTA = nilai;
Contoh :
public class CircleClass {
public static final double PI
= 3.14159265358979323846;
public double x, y, r;
// dan seterusnya
}
2.4. Method
Method merupakan tingkah laku dari suatu objek atau kelas, jika bersifat
static berarti tingkah laku semua objek dalam kelas tersebut.
Method diletakkan di dalam classbody (sebaiknya tidak
diletakkan dalam method lain).
Bentuk umum method :
[modifier] tipe_return_value namaMethod(tipe
parameter) {
methodbody;
}
Modifier boleh lebih dari satu (dipisah oleh spasi).
Pasangan tipe dan parameter dapat lebih dari satu (dipisah oleh koma).
Bentuk umum method main() sebagai berikut :
[modifier] tipe_return_value main(String
args[]) {
methodbody
}
Ada tiga sintaks pemanggilan suatu method :
namaMethod([nilaiParamater]);
namaObjek.namaMethod([nilaiParamater]);
namaKelas.namaMethod([nilaiParamater]);
Tidak semua member (class, attribute, dan method) dapat diakses method,
berikut tabel aksesnya :
|
Method
|
member (class,
attribute, method)
|
|
Static
|
static
boleh lewat objek ataupun class,
boleh langsung kalau dalam
kelas sendiri
|
|
Static
|
non static
hanya boleh lewat objek,
langsung
tidak boleh,
lewat
class tidak boleh
|
|
Non static
|
static
boleh lewat objek ataupun
class,
boleh langsung kalau dalam
kelas sendiri
|
|
Non static
|
non static
hanya boleh lewat objek,
langsung
tidak boleh,
lewat
class tidak boleh
|
Method dasar ada dua jenis yaitu getter()
dan setter().
Contoh :
public class Dog {
private int weight; //
information hiding
public int getWeight() { //getter
return weight;
}
public void setWeight(int
newWeight) { //setter
weight
= newWeight;
}
}
public class TesDog {
public static void
main(String[] args) {
Dog d = new Dog(); //
membuat objek d
d.setWeight(42); // input
System.out.println(”Dog
d’s weight is ”+d.getWeight())
}
2.4.1.
Overloading terhadap Method
Maksud overloading disini bukan overloading terhadap operator sebagaimana
C++. Overloading disini adalah mendefinisikan dua atau lebih method di dalam
kelas yang sama, dengan nama yang sama, namun dengan deklarasi parameter yang
berbeda.
Java interpreter mampu membedakan method mana yang dieksekusi dengan
mengenali tipe parameter yang dilewatkan ke method, serta mengenali return
valuenya.
Tugas dari method-method yang dioverloading tersebut berbeda.:
Contoh overloading terhadap method :
import java.lang.*;
public class Perkalian {
private double pangkat(int a,
int b) {
double hasil = 1.0;
//kode program
return hasil;
}
private double pangkat(double
a, int b) {
double hasil = 1.0;
//kode program
return hasil;
}
private double pangkat(int a,
double b) {
double hasil = 1.0;
//kode program
return hasil;
}
private double pangkat(double
a, double b) {
double hasil = 1.0;
//kode program
return hasil;
}
public static void
main(String[] args) {
Perkalian kali = new
Perkalian();
System.out.println(kali.pangkat(10,308));
// dst untuk data yg
lain
}
}
2.4.2. Keyword
this
this adalah objek yang langsung digunakan tanpa didahului proses
instansiasi.
Penggunaan keyword ini yaitu bila ada attribute (non static) dari suatu
kelas akan digunakan method yang berada dalam kelas yang sama, namun nama
attribute tersebut dan nama parameter yang dilewatkan pada method tersebut
SAMA.
Keyword ini dapat digunakan secara implicit maupun eksplisit.
Contoh penggunaan yang eksplisit :
class RectangleToy {
private double width, height;
public void setRectangle(double width,
double height) {
this.width = width;
this.height = height;
}
}
Pemanggilan attribute yang eksplisit, biasa digunakan untuk mengatasi
panamaan yang sama. Pada contoh ini parameter di method setRectangle()
menggunakan nama yang sama dengan attribute di kelas RectangleToy.
Contoh pemanggilan implisit :
class RectangleToy {
private
double width, height;
public
void setRectangle(double newwidth, double newheight) {
width = newwidth;
height = newheight;
}
}
2.5. Constructor
Pada prinsipnya constructor adalah method yang tidak memiliki return
value (secara implisit adalah instant dari kelasnya), hanya saja namanya sama
dengan nama kelas, dan dapat diberi modifier akses (public, protected, default,
private).
Bentuk umum pendefinisian constructor :
[modifier] namaConstructor(tipe
namaparameter) {
constructorBody;
}
Tujuan constructor dibuat adalah untuk melakukan inisialisasi yang
diperlukan objek baru.
Contoh constructor dan overloadingnya :
class PersonToy {
String name;
String addressLine1;
String addressLine2;
String city;
int age;
public PersonToy() {
name = ” ”;
addressLine1 = ” ”;
addressLine2 = ” ”;
city = ” ”;
age = 0;
}
public PersonToy(String
newName,
String newAddress1,
String newAddress2;
String newCity;
int newAge) {
name = newName;
addressLine1 =
newAddressLine1;
addressLine2 =
newAddressLine2;
city = newCity;
age = newAge;
}
}
2.6. Modifier
Modifier1 untuk menentukan sifat dari suatu kelas dan menentukan
preveledge (hak akses) dari kelas lain. Modifier2 untuk menentukan relasi
(extend atau implements) dengan kelas lainnya.
Wilayah modifier akses, dalam bentuk tabel :
|
Wilayah Akses
|
public
|
protected
|
default
|
private
|
|
Di kelas yg sama
|
√
|
√
|
√
|
√
|
|
Beda kelas,
di package yg sama
|
√
|
√
|
√
|
x
|
|
Beda kelas,
beda package,
di kelas turunan
|
√
|
√
|
x
|
x
|
|
Beda kelas,
beda package,
tidak di kelas turunan
|
√
|
x
|
x
|
x
|
Wilayah modifier akses tersebut dapat
diilustrasikan:
public
protected
default
private
2.6.1. Public
Menyatakan bahwa kelas/method/attribute tersebut dapat diakses oleh kelas
lain dimanapun.
2.6.2. Protected
Menyatakan bahwa kelas/method/attribute tersebut dapat diakses oleh kelas
lain yang berada dalam satu package atau kelas lain tersebut merupakan
turunannya.
2.6.3. Private
Menyatakan bahwa kelas tersebut tidak dapat diakses sama sekali oleh
kelas lain bahkan juga tidak dapat diturunkan.
Berarti attribute-attribute yang private hanya dapat
diakses oleh method-method dalam kelas yang sama, kelas lain masih dapat
mengakses melalui method-method tersebut asal modifiernya public.
Pertimbangan suatu attribute dideklarasikan private :
1.
Bila kelas lain tak memerlukan attribute tersebut.
2.
Melindungi suatu attribute dari kemungkinan nilainya
diubah oleh method lain dari kelas lain.
Final (no
extended, no overrided)
Menyatakan bahwa suatu kelas tidak dapat menurunkan (extend) kelas lain.
Menyatakan bahwa suatu method tidak dapat dioverride oleh method lain.
Membentuk suatu attribute menjadi konstanta.
Static
(no need instanciation, no overrided)
Method dan attribute ada dua jenis, yaitu method dan attribute milik
kelas serta method dan attribute milik suatu objek.
Method dan attribute milik kelas, diakses melalui tiga cara, pertama
melalui nama kelasnya, kedua melalui nama objek yang diinstant dari kelasnya,
dan ketiga bebas tanpa didahului nama kelas atau nama objeknya.
Method dan attribute milik objek, diakses hanya melalui nama objeknya.
Method static tidak bisa dioverride. Method main() harus memiliki
modifier static.
Modifier static artinya method dan attribute milik kelas, menjadi sifat
bersama dari semua objek dalam kelas tersebut (tidak memerlukan instansiasi
objek untuk menjalankannya).
Contoh System.out.println()
bersifat static artinya untuk memanggil method println() tidak harus dilakukan
instansiasi dari kelas System.
2.6.6. Abstract
(no instanciation, should be overrided)
Abstract class adalah kelas murni (tanpa objek) dan tidak boleh memiliki
objek (tidak boleh ada instansiasi) serta method-method yang abstract harus
disempurna-kan oleh kelas turunannya melalui override.
Kelas seperti ini biasanya merupakan root suatu struktur kelas.
Konsekuensi penggunaan sifat abstract :
1.
Tidak dapat dibuat constructor yang abstract.
2.
Tidak dapat dibuat method yang static dan abstract
(kedua sifat saling kontradiktif).
3.
Tidak diijinkan membuat method yang private dan
abstract (kedua sifat ini juga saling kontradiktif).
2.6.7.
Synchronized (khusus modifier method)
Pada lingkungan multithread, dimungkinkan lebih dari satu jalui eksekusi
yang berjalan di kode yang sama, kondisi tersebut dapat diatur sehingga pada
selang waktu tertentu hanya ada satu jalur eksekusi yang diijinkan di method
yang synchronized (eksekusi dilakukan secara mutual exclusive).
2.6.8.
Native (khusus modifier method)
Modifier ini digunakan untuk memanggil/mengakses method
yang ditulis dalam bahasa C/C++.
Seperti method yang abstract, method yang native hanya
berupa prototype, implementasi method ini berada di file external (dalam folder
yang sama).
2.6.9.
Transient (khusus modifier attribute)
Java memiliki konsep serialisasi, yaitu kemampuan untuk
mentransformasikan objek menjadi suatu stream, sehingga objek dapat ditransfer
dari suatu aplikasi ke aplikasi lainnya, atau dari suatu workstation ke
workstation lainnya. Prinsip ini digunakan dalam aplikasi client-server.
Salah satu ketentuan serialisasi adalah tidak boleh ada perubahan nilai
attribute suatu objek, saat objek tersebut ditransformasikan menjadi stream,
dan sebaliknya, namun suatu objek dapat memiliki nilai attribute yang boleh
berubah (bersifat transient).
2.6.10.
Volatile (khusus modifier attribute)
Dalam manajemen thread, java dapat menyimpan nilai suatu attribute (yang
sering diakses thread) menjadi cache value, sehingga tidak perlu selalu merujuk
ke lokasi memori aslinya.
Attribute tersebut bersifat volatile, karena nilainya rentan berubah bila
diakses oleh lebih dari satu thread.
2.6.11.
Extends
Bila terjadi pewarisan, kelas yang mewariskan method dan attributenya
disebut kelas super, sedangkan yang diwariskan disebut subkelas.
Kelas yang memiliki modifier ini berarti merupakan subkelas dari suatu
kelas super.
Caranya :
[modifier1] class NamaSubKelas extends NamaKelasSuper {
classBody
}
2.6.12.
Implements
Kelas yang memilki modifier2 implements artinya kelas tersebut
mengimplementasikan satu atau lebih interface. Bila terdapat lebih dari satu
interface, gunakan tanda koma di antara interface-interface tersebut.
Caranya :
[modifer] class NamaKelas implements
NamaInterface1, NamaInterface2 {
classBody
}
BAB
III. OBJEK
Pada prinsipnya objek adalah sebuah pointer. Selama
tidak bersifat static, programmer dapat melakukan sesuatu hanya terhadap objek
tertentu dari kelas.
Siklus
Hidup Objek
Suatu objek di java, terlebih dahulu harus dideklarasikan,
setelah itu mengalami pembuatan, penggunaan, kemudian penghancuran.
Deklarasi
dan Pembuatan/Instansiasi Objek
Ilustrasi
:
MyClass
mc;
MyClass
Ditentukan variabel mc
dengan tipe MyClass, dalam deklarasi mc masih berupa pointer dan belum
menunjuk alokasi memori. Keyword new
diperlukan untuk membentuk objek tsb sekaligus memanggil constructor.
|
mc
= new MyClass()
MyClass
|
|||
|
|||
|
|||
Ada 4 cara untuk melakukan deklarasi dan pembuatan objek (ingat
NamaKelas = NamaConstructor)
Cara1
:
NamaKelas namaObjek; // deklarasi
namaObjek = new NamaConstructor(); //
pembuatan
Deklarasi dan pembuatan objek boleh jadi satu dalam suatu
kelas. Deklarasi dan pembuatan objek boleh dipisah di kelas yang berbeda,
misalnya deklarasi objek di method main() pada kelas1, sedangkan
pembuatan/instansiasi objek berada pada
kelas2.
Cara2
:
NamaKelas namaObjek = new NamaConstructor();
Artinya dua proses deklarasi dan pembuatan dijadikan
satu.
Cara3
:
new NamaConstructor();
Cara ini objek diinstansiasi tanpa nama, tujuannya
hanya untuk menjalankan constructor.
Cara4
:
New NamaKelas(”…..”).namaMethod();
Penggunaan
Objek
Penggunaan objek sebenarnya untuk memanggil method yang merupakan sifat
objek tersebut.
Bentuk umum :
namaObjek.namaMethod([daftarNilaiParameter]);
namaObjek.namaAttribute;
Penghancuran
Objek
Teknik yang digunakan java untuk menangani objek yang sudah tidak
diperlukan lagi disebut garbage collection. Objek yang sudah tidak diperlukan
lagi akan terdeteksi oleh JVM, sehingga secara otomatis dihancurkan oleh
garbage collector (bukan oleh programmer).
BAB
IV. PACKAGE
4.1. Pengertian
Package
Package adalah sarana/cara pengelompokkan dan pengorganisasian
kelas-kelas dan interface yang sekelompok menjadi suatu unit tunggal dalam
library.
Package juga mempengaruhi mekanisme hak akses ke kelas-kelas di dalamnya.
4.2. Pengaruh
Package terhadap Method main()
Kelas yang mengandung method main() memilki syarat tidak berada dalam
suatu package, dan hirarki posisi foldernya di atas package yang diimport.
4.3. Membuat
Package
Ada tiga langkah untuk membuat package :
1.
Mendeklarasikan dan memberi nama package.
2.
Membuat struktur dan nama direktori yang sesuai dengan
struktur dan nama package.
3.
Mengkompilasi kelas-kelas sesuai dengan packagenya
masing-masing.
4.4.
Mendeklarasikan dan Memberi Nama Package
Deklarasi package harus diletakkan pada bagian paling awal (sebelum
deklarasi import) dari source code setiap kelas yang dibungkus package
tersebut.
Bentuk umum deklarasi package :
package namaPackage;
Deklarasi tersebut akan memberitahukan kompilator, ke library manakah
suatu kelas dikompilasi dan dirujuk.
Syarat nama package :
1.
Diawali huruf kecil
2.
Menggambarkan kelas-kelas yang dibungkusnya
3.
Harus unik (berbeda dengan nama package standard)
4.
Merepresentasikan path dari package tersebut.
5.
Harus sama dengan nama direktorinya.
Contoh package standard :
java.lang (berisi kelas-kelas
fundamental yang sering digunakan).
java.awt dan javax.swing (berisi kelas-kelas untuk membangun aplikasi GUI)
java.io (berisi kelas-kelas untuk proses
input output)
4.5.
Membuat Struktur Direktori
Pada langkah ini, buatlah direktori menggunakan file manager (di windows
menggunakan explorer) sesuai struktur package dari langkah sebelumnya. Kemudian
tempatkan kelas-kelas tersebut ke direktori yang bersesuaian (mirip
seperti menyimpan file-file ke dalam
folder).
Package dapat bersarang di package lain, sehingga dapat dibuat hirarki
package.
Bentuk umum pernyataan package multilevel :
package
namaPackage1[.namaPackage2[.namaPackage3]];
Contoh hirarki package di JDK :
package java.awt.image;
4.6. Compile dan Run Kelas dari suatu Package
Selanjutnya masing-masing kelas tersebut dalam package tersebut
dikompilasi menjadi byte code (*.class). Artinya package tersebut siap
digunakan.
4.7.
Menggunakan Package
Ada dua cara menggunakan suatu package yaitu :
1.
Kelas yang menggunakan berada dalam direktori (package)
yang sama dengan kelas-kelas yang digunakan. Maka tidak diperlukan import.
2.
Kelas yang menggunakan berada dalam direktori (package)
yang berbeda dengan kelas-kelas yang digunakan. Maka pada awal source code di
kelas pengguna harus mencantumkan :
import namaPackage.NamaKelas; atau
import namaPackage.*;
Contoh :
import java.text.DecimalFormat;
import javax.swing.*;
4.8. Setting
Classpath
Path hirarki package, didaftarkan sebagai salah satu
nilai variabel lingkungan yang bernama Classpath.
Classpath diset dengan aturan : berawal dari drive (C:\
atau D:\) sampai dengan satu tingkat sebelum kita mendeklarasikan package.
BAB
V. INFORMATION HIDING, ENCAPSULATION, INHERITANCE, DAN POLYMORHISM
5.1.
Latar Belakang Encapsulation
Vendor perangkat lunak computer merahasiakan source code produknya, user hanya diberitahu melalui manual cara menggunakan produknya.
Programmer java pun tidak perlu mengetahui bagaimana rinci source code
dari modul antarmuka referensi (API), programmer hanya perlu tahu return value
dan parameter milik method-methodnya, atau hanya perlu tahu parameter milik constructor-constructornya.
5.2. Information
Hiding dan Encapsulation
Information Hiding adalah menyembunyikan attribute suatu objek dari objek
lain.
Encapsulation adalah menyembunyikan method suatu objek dari objek lain.
Attribute maupun method disembunyikan dengan cara memberikan modifier
private.
Method dalam kelas yang sama, yang memberikan nilai pada attribute
private disebut method setter, sedangkan method masih dalam kelas yang sama,
yang mengambil nilai dari attribute private disebut getter.
// Contoh program Information
Hiding dan Encapsulation
public class PersegiPanjang{
private double panjang; //
attribute yg di hide
private double lebar; // attribute yg di hide
private double tinggi; //
attribute yg di hide
public PersegiPanjang() {
panjang = 0;
lebar = 0;
}
private double luas(double p,
double l) { // di encap
return p*l;
}
public void setPanjang(double
panjang) {
this.panjang = panjang;
}
public void setLebar(double
lebar) {
this.lebar = lebar;
}
public double getPanjang() {
return panjang;
}
public double getLebar() {
return lebar;
}
public double getLuas() {
return luas(panjang,
lebar);
}
}
public class MainPersegiPanjang {
public static void
main(String[] srgs) {
PersegiPanjang pp = new
PersegiPanjang();
pp.setPanjang(10);
pp.setLebar(20);
System.out.println(”Panjang : ”+ pp.getPanjang());
System.out.println(”Lebar
: ”+ pp.getLebar());
System.out.println(”Luas :
”+ pp.getLuas());
}
}
5.3. Inheritance
Semua attribute dan method dari suatu kelas super dapat diwariskan ke
subkelas.
Dalam hirarki kelas, jika kelas C merupakan turunan kelas B, dan kelas B
merupakan turunan kelas A, maka otomatis attribute dan method kelas A juga
diwariskan kelas C.
Bentukpewarisan :
[modifier] class namaSubKelas extend
namaKelasSuper {
//
classBody
}
5.4. Manfaat
Pewarisan
Tanpa inheritance, maka semua attribute dan method yang pernah dibuat dan
butuhkan kelas lain, harus ditulis ulang seluruhnya.
Dengan inheritance, seorang programmer ingin memodifikasi suatu attribute
atau method yang dimanfaatkan subkelas, maka dilakukan modifikasi attribute dan
method tersebut pada kelas supernya.
5.5. Overrriding
Attribute dan Method
Overriding adalah kemampuan suatu subkelas untuk memodifikasi attribute
dan method milik kelas supernya (tentu yang memiliki sifat private atau final
tidak biasa dilakukan overriding).
Modifikasi yang dilakukan, misalnya jumlah parameter, tipe parameter,
tipe return value, ataupun lingkungan pemrosesan datanya.
// Contoh program overriding
class KelasSuper {
public void methodAsli() {
System.out.println(”Method
milik KelasSuper jalan”);
}
public static void
main(String[] args) {
KelasSuper oks = new
KelasSuper();
oks.methodAsli();
}
}
class SubKelas extends KelasSuper {
public void methodAsli() {
System.out.println(”Method yg overrided
jalan”);
}
public void methodPemanggil()
{
System.out.println(”Method
pemanggil methodAsli jln”);
super.methodAsli(); // yg
dipanggil milik kelas super
}
public static void main(String[]
args) {
SubKelas osk = new
SubKelas();
osk.methodAsli();
osk.methodPemanggil();
}
}
5.6. Menggunakan
Method dan Constructor Kelas Super
Java tidak memperbolehkan subkelas memanggil contructor milik kelas
supernya dengan cara hanya memanggil namanya.
Cara yang
benar :
super();
super(tipe parameter);
Cara yang pertama, akan memanggil constructor default milik kelas
supernya, sedangkan cara kedua, akan memanggil constructor kelas supernya yang
sesuai dengan parameter tersebut.
Jika ada overriding, misal nama methodnya namaMethod(), maka cara pemanggilan method (non static) milik kelas super :
super.namaMethod(); // perhatikan contoh pada 5.5
Sehingga dapat dibedakan namaMethod()
milik siapa yang dipanggil.
5.7.
Polymorphism
Polymorphism artinya bersifat poly morphy (memiliki banyak bentuk).
Method-method overloading masih dalam kelas yang sama, namun contoh
berikut memvisualisaikan method respon()
nama sama, namun pada kelas yang berbeda dapat memilki isi method yang berbeda
pula tergantung kelasnya.
Contoh pertama :
class EkspresiWajah{
public String respons() {
return(”Perhatikan
ekspresi wajah saya”);
}
}
}
class Gembira extends EkspresiWajah{
public String respons() {
return(”ha ha ha…”);
}
}
}
class Sedih extends EkspresiWajah{
public String respons() {
return(”hik hik ngeee ngeee
ngeee”);
}
}
}
class Marah extends EkspresiWajah{
public String respons() {
return(”Hai kurang ajar…!”);
}
}
}
class MainEkspresiWajah{
public static void main(String
args[]) {
EkspresiWajah objEkspresi
= new EkspresiWajah();
Gembira objGembira = new
Gembira();
Sedih objSedih = new
Sedih();
Marah objMarah = new
Marah();
EkspresiWajah[]
arrEkspresi = new EkspresiWajah[4];
arrEkspresi[0] = objEkspresi;
arrEkspresi[1] =
objGembira;
arrEkspresi[2] =
objSedih;
arrEkspresi[3] =
objMarah;
System.out.println(”Ekspresi[0]
: ”+arrEkspresi[0].respons());
System.out.println(”Ekspresi[1]
: ”+arrEkspresi[1].respons());
System.out.println(”Ekspresi[2]
: ”+arrEkspresi[2].respons());
System.out.println(”Ekspresi[3]
: ”+arrEkspresi[3].respons());
}
}
}
Contoh kedua :
public class Employee {
private String name;
private double salary;
protected Employee(String n,
double s) {
name = n;
salary = s;
}
protected String getDetails()
{
return ”Name : ”+name+
”\nSalary : ”+salary;
}
public void cetak() {
System.out.println(”coba
di Employee”);
}
}
public class Manager extends Employee {
private String department;
public Manager(String nama,
double salary, String dep) {
super(nama, salary);
department = dep;
}
public String getDepartment()
{
return department;
}
public String getDetails() {
return
super.getDetails()+ ”\nDepartment : ”+getDepartment();
}
public void cetak() {
System.out.println(”Coba
di Manager”);
}
}
public class View {
public static void
main(String[] args) {
Employee e = new
Employee(”Ali”,1200000);
Employee em = new
Manager(”Ali”,1200000,”Informatika”);
System.out.println(”Data
employee :\n”+e.getDetails());
System.out.println(”Data
manager :\n”+em.getDetails());
em.cetak();
}
}
Catatan :
Kalau method cetak() di kelas Employee dan kelas Manager ada, maka yang
dijalankan adalah method milik kelas Manager.
Prioritasnya
adalah kelas Manager kemudian kelas Employee.
BAB VI. KELAS INNER,
KELAS ABSTRCT,
DAN
INTERFACE
6.1. Kelas Inner
Java membolehkan programmer menyisipkan suatu kelas ke dalam kelas
lainnya. Kelas sisipan ini disebut kelas Inner.
Kelas Inner berguna untuk mendukung suatu proses yang akan dijalankan
oleh kelas luarnya.
Beberapa ketentuan kelas Inner :
a)
Kelas Luar yang mengandung kelas Inner, bila
dikompilasi akan menghasilkan dua file *.class, yaitu Luar.class dan Luar$Inner.class
b)
Kelas Inner boleh tidak diberi nama, yang disebut
Anonymous Inner.
c)
Kelas Inner dapat diberi modifier akses public, atau
protected, atau default, ataupun private.
d)
Untuk mengakses referensi this dari kelas luar
digunakan bentuk NamaKelasLuar.this.
e)
Kelas Luar ikut bertanggung-jawab dalam instansiasi
kelas Inner (yang non static). Kalau objek kelas Luar adalah a, dan objek kelas
Inner adalah b, maka sintaks yang benar adalah :
Luar a = new Luar();
Luar.Inner b = a.new Inner();
f)
Jika kelas Inner bersifat static, maka objek milik
kelas Inner dapat dibuat sendiri tanpa melalui kelas Luarnya, (Artinya kelas
Inner tidak dapat mengakses attribute ataupun method non static milik kelas
Luarnya).
6.2.
Menggunakan Kelas Inner
Kelas Inner lazim digunakan untuk membuat handler di method main() pada suatu aplikasi GUI.
Handler
merupakan bagian program yang akan memproses event-event yang dipicu ketika
user berinteraksi dengan komponen-komponen GUI.
Contoh program berikut adalah aplikasi Button sederhana
dengan handlernya dari kelas Inner :
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class DemoJButtonInner extends JFrame
{
private JButton btn;
public DemoJButtonInner {
super(”Demo JButton Inner Class”);
Container c = getContentPane();
c.setLayout(new FlowLayout());
btn = new JButton(”Button”);
c.add(btn);
// membuat event handler
ButtonHandler handler = new ButtonHandler();
btn.addActionListener(handler);
setSize(275, 100);
show();
}
public static void main(String args[]) {
DemoJButtonInner app = new DemoJButtonInner();
app.addWindowListener(new WindowAdapter() {
public void
windowClosing(WindowEvent we) {
System.exit(0);
}
});
}
// kelas Inner untuk Event Handling pada button
private class ButtonHandler implements
ActionListener {
public void actionPerformed(ActionEvent
ae) {
JOptionPane.showMessageDialog(null,
”anda telah menekan”
+ae.getActionCommand()+”\n”
+”Handler button ini pakai kelas
Inner”);
}
}
}
6.3.Kelas
Abstract
Kelas abstract adalah kelas murni yang tidak boleh
memiliki objek, dan satu/lebih method-methodnya yang abstract harus diimplementasikan
(override) oleh kelas turunannya.
Bentuk umum :
[modifier] abstract class NamaKelas {
// deklarasi attribute
// definisi/prototype method
}
6.3.1.
Analogi Kelas yang Abstract
Suatu kelas dapat diinstansiasi menjadi objek, misal kelas
Dosen dapat diinstansiasi menjadi budi, heri, heru, namun tidak mungkin dapat
menginstansiasi kelas MahlukHidup, kelas Hewan, dan kelas Manusia, sebab kelas
tersebut terlalu umum (abstract), kelas seperti inilah yang disebut kelas abstract.
Dibutuhkan kelas turunan yang lebih khusus.
6.3.2.
Analogi Method yang Abstract
Bila kelas MahlukHidup mempunyai method bernafas, maka
tidak dapat ditentukan cara suatu mahluk hidup tersebut bernafas (dengan paru-paru,
insang, atau stomata), method seperti inilah yang disebut method abstract.
Dibutuhkan kelas turunan yang khusus dan method
override dari method yang abstract.
6.4.
Interface
Interface adalah kelas yang paling abstract, yang berisi
daftar deklarasi method (seluruh method belum memiliki implementasi).
6.4.1.
Analogi Interface
Interface dapat dianalogikan sebagai kontrak yang dapat
dipakai oleh setiap kelas.
Dalam kehidupan nyata dapat diketahui ada manusia yang
bekerja sebagai da’i, dosen, 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 seorang budi bekerja
sebagai dosen, harus dibuat kelas yang merupakan turunan kelas manusia yang
meng-implementasikan interface dosen.
6.5.
Deklarasi Interface
Bentuk umum deklarasi:
[modifier] interface NamaInterface {
//
deklarasi konstanta
// deklarasi method
} //
catatan : modifier static tidak boleh digunakan dalam interface
6.6.
Implementasi Interface
Bentuk umum implementasi :
[modifier] class NamaKelas implements
NamaInterface {
// penggunaan konstanta
//
implementasi method
}
6.7.
Contoh Abstract Class dan Interface
abstract class Hewan {
protected
String nama;
protected int jumKaki;
protected
boolean bisaTerbang = false;
public Hewan(String nama, int kaki, boolean terbang) {
this.nama = nama;
jumKaki = kaki;
bisaTerbang = terbang;
}
public abstract void bersuara();
public void static makan() {
System.out.println(”nyam, nyam, nyam”);
}
public void isHewan() {
System.out.println(”nama : ”+nama);
System.out.println(”jumlah kaki : ”+jumKaki);
System.out.println(”bisa terbang : ”+bisaTerbang);
}
}
interface Manusia {
public void menyanyi();
public void ketawa();
}
class Perkutut extends Hewan {
public
Perkutut()
super(”perkutut”,2,true);
}
public void bersuara() {
System.out.println(”\ncuit, cuit, cuit”);
}
public
static void main(String[] args) {
Perkutut p = new Perkutut();
p.isHewan();
p.bersuara();
}
}
//**************************************
class Sapi extends Hewan {
public Sapi() {
super(”sapi”, 4, false);
}
public void bersuara() {
System.out.println(”\nemoh…,emoh…”);
}
public static void main(String[] args) {
Sapi s = new Sapi();
s.isHewan();
s.bersuara();
}
}
class SpongeBob extends Hewan implements
Manusia {
public SpongeBob() {
super(”sponge bob”, 2, false);
}
public void bersuara() {
System.out.println(”\nhallo patrict…..”);
}
public void menyanyi() {
System.out.println(”nye, nye, nye, wik, wik, wik”);
}
public void ketawa() {
System.out.println(”kek, kek, kek”);
}
public static void makan() {
System.out.println(”uenak tenan…”);
}
public void makan2() {
super.makan();
}
public static void main(String[] args) {
SpongeBob = s new SpongeBob();
s.isHewan();
s.bersuara();
s.menyanyi();
s.ketawa();
s.makan2();
Hewan.makan();
makan()
}
}
6.8.
Interface vs Class
Perbandingan interface dengan class :
|
komponen
|
interface
|
class
|
|
definisi
|
daftar
deklarasi method
|
model objek
|
|
kandungan
informasi
|
isi/implementasi
semua methodnya berada di luar interface ini
|
mendefinisikan
attribute dan method secara rinci dan konkret
|
|
instansiasi
|
tidak boleh
|
boleh
|
6.9.
Interface vs Inheritance
Inheritance adalah proses pewarisan attribute dan method
dari satu kelas super kepada satu/lebih subkelas.
Bagaimana kalau dibutuhkan suatu kelas yang attribute dan
methodnya berasal dari lebih dari satu kelas super ? disinilah keterbatasan
inheritance, namun interface berperan, karena dalam interface bisa dimasukkan
method-method dari beberapa library referensi tanpa harus menurunkannya.
Syntax kelas yang menggunakan lebih dari satu interface :
[modifier] class NamaKelas implements
NamaInterface1, NamaInterface2, … {
//interfaceBody
}
Nama-nama interface tersebut dapat dijadikan tipe data
attribute ataupun tipe data parameter dalam kelas yang menggunakan.
6.10.
Interface vs Abstract Class
Interface dan kelas abstract memilki kesamaan sama-sama tidak boleh
instansiasi objek.
Perbedaan interface dangan kelas abstract adalah sebagai berikut :
|
komponen
|
interface
|
abstract
class
|
|
attribute
|
hanya berupa konstanta
|
bebas memilki tipe data apa saja
|
|
method
|
berupa deklarasi
|
boleh deklarasi, boleh berupa method lengkap
|
|
syntax
|
seluruhnya abstract (berupa deklarasi)
|
sebagian abstract
|
6.11.
Aplikasi Interface
Interface sering digunakan untuk menambah event handling pada program aplikasi GUI, perhatikan contoh berikut
:
//membuat aplikasi JButton implementasi
interface :
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class AppJButton extends JFrame implements ActionListener {
private JButton btn;
public AppJButton() // constructor
super(”Demo JButton Interface”);
Container c =
getContentPane();
c.setLayout(new
FlowLayout());
btn = new
JButton(”Button”);
c.add(btn);
btn.addActionListener(this);
setSize(275, 100);
show();
}
public static void
main(String args[]) {
AppJButton app = new
AppJButton();
App.addWindowListener(new
WindowAdapter() {
public void
windowClosing(WindowEvent we) {
System.exit(0);
}
});
}
public void
actionPerformed(ActionEvent ae) {
JOptionPane.showMessageDialog(null,
”Anda telah menekan : ”+
e.getActionCommand()+”\n”+
”Handler Button ini
mengimplementasikan interface”);
}
}
BAB
VII. EXCEPTION HANDLING
7.1.Pendahuluan
Error dalam pemrograman dibagi dalam tiga katagori yaitu syntax error (saat kompilasi), run time error, dan logic error (output belum sesuai dengan yang diharapkan).
Exception dipicu oleh run time
error dan digunakan sebagai sarana melaporkan kondisi-kondisi kesalahan.
Jenis-Jenis
Exception
Dalam java, exception merupakan objek dari subkelas yang diturunkan dari
kelas Throwable. Kelas Throwable ini terdapat dalam package java.lang.object.
Kelompok
Kelas Error
Error ini bersifat fatal sehingga sistem tidak dapat dimanipulasi untuk
diperbaiki, contoh kelas: LinkageError,
VirtualMachineError, dan AWTError.
Kelompok
Kelas Exception
Jenis error ini masih dapat diantisipasi dengan menyisipkan statement
tambahan untuk mendeteksi data yang berpotensi menimbulkan error.
Ada kelompok exception yang diperiksa oleh interpreter, apakah akan ditangani
atau dilempar, namun ada pula exception yang akan tidak diperiksa interpreter.
Disamping itu programmer dibolehkan membuat exception sendiri dengan cara
extends atau implements kelas Exception.
Checked
Exception
|
No
|
Exception
|
Deskripsi
|
|
1
|
ClassNotFoundException
|
Kelas tidak ditemukan
|
|
2
|
CloneNotSupportedException
|
melakukan clone objek yang tidak mengimplementasikan
interface Cloneable
|
|
3
|
IllegalAccessException
|
Pengaksesan ke kelas ditolak
|
|
4
|
InstantiationException
|
Menciptakan objek dari kelas abtract ataupun dari
interface
|
|
5
|
InterruptedException
|
Thread telah diinterupsi oleh thread lain
|
|
6
|
NoSuchFieldException
|
Field yang diminta tidak ada
|
|
7
|
NoSuchMethodException
|
Method yang diminta tidak ada
|
Uncheked
Exception
|
No
|
Exception
|
Deskripsi
|
|
1
|
AritmaticException
|
Kesalahan Aritmatik seperti pembagian dengan nol
|
|
2
|
ArrayIndexOutBoundsException
|
Index array di luar batas
|
|
3
|
ArrayStoreException
|
Pemberian nilai ke elemen array tidak sesuai dengan
tipenya
|
|
4
|
ClassCastException
|
Cast yang tidak sah
|
|
5
|
IllegalArgumentException
|
Argument illegal
|
|
6
|
IllegalMonitorStateException
|
Operasi monitor illegal seperti menunggu di thread yang
tidak terkunci
|
|
7
|
IllegalStateException
|
Lingkungan atau aplikasi state yang tidak benar
|
|
8
|
IllegalThreadStateException
|
Operasi yang diminta tidak kompatibel dengan state thread
saat itu
|
|
9
|
IndexOutOfBoundException
|
Indeks di luar batas
|
|
10
|
NegativeArraySizeException
|
Array diciptakan dengan ukuran negatif
|
|
11
|
NullPointerException
|
Penggunan null yang tidak sah
|
|
12
|
NumberFormatException
|
Konversi yang tidak sah dari string ke format numerik
|
|
13
|
SecurityException
|
Melanggar
aturan security
|
|
14
|
StringIndexOutOfBounds
|
Index di luar batas string
|
|
15
|
UnsupportedOperationException
|
Ditemukan operasi yang tidak didukung
|
Dua Exception yang belum dikelompokkan, yaitu IOException dan AWTException.
Mengantisipasi
Exception
Diperlukan tiga langkah berikut ini untuk mengantisipasi exception :
1.
Mendeklarasikan Exception
Bentuk umum :
[modifier] returntype
namaMethod() throws tipeException{
}
Contoh :
public void
operasiMatematika() throws IOException,
ClassNotFoundException {
}
public void beriPinjaman()
throws TolakException{
}
2.
Melempar Exception
Bentuk umum :
TipeException namaObjek = new TipeException;
throw namaObjek;
Diringkas
menjadi :
throw namaObjek TipeException;
atau
throw new TipeException();
Contoh :
TolakException t = new TolakException(”lagi
pelit”);
throw t;
Diringkas menjadi
:
throw new TolakException(”lagi
pelit!”);
3.
Menangkap Exception
Penangkapan runtime error, dapat mempunyai beberapa blok yang menangkap
setiap jenis exception.
Bentuk umum :
try {
// pemanggilan method yg mungkin
menghasilkan exception
//
blok statement yg mungkin menghasilkan exception
}
catch(TipeException1 namaObjek) {
// penanganan salah-satu jenis exception
}
catch(TipeException2 namaObjek) {
// penanganan salah-satu jenis exception
}
catch(TipeExceptionN namaObjek) {
// penanganan salah-satu jenis exception
}
finally {
// blok yang harus dieksekusi
}
Jika pada blok try tidak terjadi
exception, maka blok catch tidak ada yang dieksekusi dan
segera blok finally yang dieksekusi.
Jika terjadi exception pada
blok try, maka salah satu blok catch dieksekusi, kemudian blok finally dieksekusi.
Mekanisme
Mengantisipasi Exception
Ada tiga kemungkinan skenario exception, pertama jika tidak terjadi
exception (tidak ada blok catch yang dieksekusi), kedua jika exception terjadi
pada blok method tunggal (salah-satu blok catch dieksekusi), ketiga jika
terjadi exception pada blok tersarang.
|
Method
A {
…
try {
…
memanggil method B;
 }
catch(Exception1 obj1) {
proses Obj1;
}
…
}
|
Method B {
…
try {
…;
}
catch(Exception2 obj2) {
proses Obj2;
}
…
}
|
Menampilkan
Pesan Exception
Beberapa method standard yang dapat digunakan untuk menampilkan pesan
exception merupakan anggota dari kelas java.lang.Throwable.
|
No
|
Method Pesan
Exception
|
Deskripsi
|
|
1
|
getMessage()
|
Mengembalikan nilai string yang berisi pesan rinci
tentang objek Throwable yang mengalami exception
|
|
2
|
toString()
|
Mengembalikan nilai string yang berisi pesan singkat
tentang objek yang mengalami exception
|
|
3
|
getLocalizedMessage()
|
Menampilkan pesan exception lokal (yang terjadi pada
subkelas saja)
|
|
4
|
printStackTrace()
|
Method ini bersifat void, dan hanya mencetak informasi
tentang objek Throwable
|
BAB
VIII. KELAS-KELAS DASAR
Ingat di java, suatu string adalah objek.
Ada dua kelas string yang akan dibahas yaitu kelas String, kelas StringBuffer.
8.1. Kelas
String
Kelas String memodelkan deretan karakter. Kelas ini terdapat dalam
java.lang. Sesuai dengan kuantitas constructornya, ada 7 cara untuk membuat
objek String:
String(); // cara1
String(String value); // cara2
String(char value[]); // cara3
String(byte ascii[], int hibyte); // cara4
String(char value[], int offset,
int count); // cara5
String(byte ascii[], int hibyte,
int offset, int count); //cara6
String(StringBuffer buffer); // cara7
Contoh
penggunaan Constructor tersebut :
String aString1 = new String(); // cara1
String aString2 = new
String(”haii…”); // cara2
char aArray[] = {’H’,’E’,’L’,’L’,’O’};
String aString3 = new String(aArray); // cara3
String aString4 = new
String(aArray,0,4); // cara5
System.out.println(aString4); // HELL
Ada 33 method yang digunakan untuk melakukan 8 macam operasi pada kelas
String, yaitu :
int length;
char charAt(int index);
boolean startsWith(String prefix);
boolean startsWith(String prefix,
int tooffset);
boolean endsWith(String suffix);
int indexOf(int i);
int indexOf(int i, int fromIndex);
int indexOf(String str);
int indexOf(String str, int
fromIndex);
int lastIndexOf(int i);
int lastIndexOf(int i, int
fromIndex);
int lastIndexOf(String str);
int lastIndexOf(String str, int fromIndex);
String substring(int beginIndex);
String substring(int beginIndex,
int endIndex);
boolean equels(Object anObject);
boolean equelsIgnoreCase(String
aString);
int compareTo(String str);
int compareTo(Object anObject);
String concat(String s);
String replace(char oldChar, char
newChar);
String trim();
String toLowerCase();
String toUpperCase();
static String valueOf(Object
anObject);
static String valueOf(char ch[]);
static String valueOf(char ch[],
int offset, int count);
static String valueOf(boolean b);
static String valueOf(char ch);
static String valueOf(int i);
static String valueOf(long l);
static String valueOf(float f);
static String valueOf(double d);
Ada 8 operasi pada kelas String, yaitu :
1.
Membuat dan menginisialisasi String
String saran = ”Raihlah scjp”;
String saran = new String(”Raihlah
scjp”);
2.
Membaca character dalam String
int len = saran.length(); // 12
char ch = saran.charAt(3); // i
3.
Membandingkan dua String
String s1 = new String(”abcd”);
String s2 = new String(”abcdz”);
System.out.println(s1.equels(s2));
// true
System.out.println(s1.equelsIgnoreCase(”ABCFJ”);
// hasilnya true
System.out.println(s1.compareTo(s2);
hasilnya 0, jika s1 sama dengan s2
hasilnya < 0, jika s1 < s2
hasilnya > 0, jika s1 > s2
Catatan :
Membandingkan nilai-nilai di attribute int, long, float, dan double,
harus mengunakan operator ==, namun operator ini tidak berlaku untuk
objek-objek milik kelas String. Jika contoh di atas dilakukan s1==s2, maka hasilnya selalu false.
4.
Mengubah character kecil menjadi capital
String s1 = new String(”Raihlah
scjp \n”);
String s2 = s2.trim(); //
Raihlah scjp (tanpa spasi)
System.out.println(s2.toLowerCase());
System.out.println(s2.toUpperCase());
5.
Concatenation dua String
String s1 = new String(”Saya
belajar j2se”);
String s2 = new String(s1+ ”
sendiri”);
String s3 = new String(s2+ ” di
rumah”);
System.out.println(s3);
6.
Mencari character dan substring
String aString = new String(”Nilai
objek milik kelas String”);
int index1 = aString.indexOf(’a’);
// index1 berisi posisi ’a’
int index2 = aString.indexOf(’a’,index1+1);
// index2 berisi posisi kemunculan kedua huruf ’a’
int index3 = aString.indexOf(”String”);
// index3 berisi lokasi karakter ’g’ pada aString
int index4 = aString.indexOf(”i”);
// index4 berisi lokasi karakter i pada aString
boolean hasil1 =
aString.startWith(”Nilai”); // true
boolean hasil = aString.endsWith(”String”);
// true
7.
Mengambil suatu substring
String strAsli = new String(”Saya
belajar j2se”);
String strBaru1 = strAsli.substring(12);
// strBaru1 berisi string mulai index
ke-12
String strBaru2 = strAsli.substring(5, 10);
// strBaru2 berisi string mulai index ke-5 sampai ke-10
8.
Menggantikan suatu character dalam String
String strBaru3
= strAsli.replace(’S’,’m’);
System.out.println(strBaru3);
// maya belajar j2se
8.2. Kelas
StringBuffer
Kelas ini bisa menciptakan objek berupa string yang dapat berubah
(padahal objek pada kelas String berupa konstanta).
Method-method pada kelas ini, dapat beroperasi langsung pada buffer yang
berisi string.
Ada tiga constructor milik kelas StringBuffer :
public StringBuffer();
public StringBuffer(int n);
public StringBuffer(String str);
Contoh
penggunaan constructor :
String s1 = new String(”Belajar
StringBuffer”);
//
menciptakan objek StringBuffer yang kosong
// dengan karakter
inisial sebanyak 16 karakter
String sb1 = new StringBuffer();
//
menciptakan objek StringBuffer yg panjangnya 32 char
//
diinisialisasi dengan spasi
String sb2 = new StringBuffer(32);
//
menciptakan objek StringBuffer sepanjang String s1
// dengan
karakter inisial 16 karakter
String sb3 = new StringBuffer(s1);
Beberapa method yang digunakan untuk memodifikasi isi buffer yang berisi
string.
StringBuffer s1 = new
StringBuffer(14);
System.out.println(”Kapasitas = ”+ s1.capacity());
//14
System.out.println(”Panjang = ”+ s1.length());
// 0
s1.setLength(3);
System.out.println(s1); // Bel
System.out.println(”Kapasitas = ”+ s1.capacity());
//14
System.out.println(”Panjang = ”+ s1.length());
// 3
Contoh penggunaan method charAt() dan setCharAt() :
StringBuffer s1 = new
StringBuffer(”Belajar StringBuffer”);
char c1 = s1.charAt(9);
System.out.println(c1); // S
s1.setCharAt(4,’r’);
System.out.println(s1); //
Belrjar StringBuffer
Beberapa overloading method append()
dan insert() :
synchronized StringBuffer append(Object
obj);
synchronized StringBuffer append(String str);
synchronized StringBuffer append(char ch);
synchronized StringBuffer append(char ch[]);
synchronized StringBuffer
append(char str[], int offset, int len);
StringBuffer append(boolean b);
StringBuffer append(int i);
StringBuffer append(long l);
StringBuffer append(float f);
StringBuffer append(double d);
synchronized StringBuffer insert(int offset,
Object obj);
synchronized StringBuffer insert(int offset,
String str);
synchronized StringBuffer insert(int offset,
char ch);
synchronized StringBuffer
insert(int offset, char ch[]);
StringBuffer insert(int offset, boolean b);
StringBuffer insert(int offset, int i);
StringBuffer insert(int offset, float f);
StringBuffer insert(int offset,
double d);
Contoh pengunaan method append() dan insert() :
StringBuffer sb1 = new
StringBuffer(”2 + 2 = ”);
StringBuffer sb2 = new
StringBuffer(”Raihlah scjp”);
sb1.append(2+2);
sb2.append(” depan”);
sb2.insert(14, ”tahun”);
System.out.println(sb1);
System.out.println(sb2);
8.3. Kelas Math
dan Kelas StrictMath
Kelas Math berisi sekumpulan method dan konstanta matematika.
Kelas ini bersifat final (tidak
dapat diturunkan, dan tidak dapat melakukan instansiasi), dan semua attribute
dan methodnya bersifat static.
Java2 mulai versi1.3 menambah kelas StrinctMath yang berisi sekumpulan
method matematika yang lengkap, serupa dengan kelas Math. Perbedaannya adalah
StricMath dijamin menghasilkan hasil identik yang presisi diimplementasikan di
Java manapun.
Method-method di kelas Math :
static double toRadians(double
sudut);
static double toDegrees(double
sudut);
static double sin(double d);
static double cos(double d);
static double tan(double d);
static double asin(double d);
static double acos(double d);
static double atan(double d);
static double exp(double d); //
e pangkat d
static double log(double d); //
ln(d);
static double sqrt(double d); //
static double pow(double a, double
b); // a pangkat b
static double ceil(double d); //
pembulatan ke atas
static double floor(double d);
//pembulatan ke bawah
static int round(float f); //
pembulatan biasa
static long round(double d); //
pembulatan biasa
static double rint(double d);
// pembulatan ke int terdekat
static double atan2(double a,
double b); // cartesius ke polar
static synchronized double
random();
Lanjutan method-method di kelas Math :
static int abs(int i);
static long abs(long l);
static float abs(float f);
static double abs(double d);
static int min(int a, int b);
static long min(long a, long b);
static float min(float a, float b);
static double min(double a, double
b);
static int max(int a, int b);
static long max(long a, long b);
static float max(float a, float b);
static double max(double a, double
b);
Math.E=2.7…; Math.PI=3.14…;
Penggunaan method-method pada kelas Math :
double d = Math.sin(Math.PI/2);
double d1 = 12.3;
double d2 = Math.exp(d1);
double d3 = Math.log(d1);
double d4 = Math.sqrt(d1);
double d5 = Math.pow(d1, 3.0);
double d6 = Math.ceil(7.3); //
hasilnya 8
double d7 = Math.ceil(-7.3); //
hasilnya -7
double d8 = Math.floor(7.3); //
hasilnya 7
double d9 = Math.floor(-7.3); //
hasilnya -8
double d10 = 37.125;
int i = Math.round((float) d10);
long l = Math.round(d10);
double d11 = 14.2, d12 = 18.5;
double d13 = Math.min(d11, d12);
double d14 = Math.max(d11, d12);
static double random(); // 0.0
<=hasil<=1.0
8.4. Kelas-Kelas
Tipe Data Wrapper
Sembilan tipe data dasar (boolean, byte,
char, double, float, int, long, short, void) di java tidak diimplementasikan
sebagai kelas. Kelas wrapper bertindak sebagai versi kelas dari tipe data
dasar, yang namanya serupa namun diawali huruf kapital.
Jadi kelas tipe data wrapper di java ada sepuluh yaitu Boolean, Byte, Character, Double, Float,
Integer, Long, Number, Short, Void.
Penting untuk diperhatikan bahwa tipe data wrapper dan tipe data dasar tidak saling menggantikan.
Tipe data dasar diperoleh dari tipe data wrapper dengan cara memanggil
method di tipe data wrapper.
Tipe data dasar dilewatkan ke
method dengan pass by value, jadi
jika membutuhkan pass by reference
harus memanfaatkan kelas tipe data wrapper.
Kelas-kelas tipe data wrapper menyediakan versi objek dari tipe data
dasar, maka dimungkinkan menambah method-method untuk masing-masing tipe.
Ada enam subkelas kongkret yang menyimpan nilai-nilai secara eksplisit
masing-masing tipe data dasar yaitu double, float, byte, short, integer, dan
long.
Kelas Number
Kelas ini bersifat abstract serta mendefinisikan super kelas yang
diimplementasikan oleh kelas-kelas yang membungkus tipe data dasar.
Method-method dari kelas Number :
byte byteValue();
double doubleValue();
float floatValue();
int intValue();
long longValue();
short shortValue();
Kelas Boolean
Kelas ini membungkus tipe data dasar Boolean, dan memiliki dua
constructor yaitu:
Boolean(Boolean boolValue);
Boolean(String boolString);
Method-method di kelas ini adalah :
boolean booleanValue();
boolean equels(Object boolObj);
static boolean getBoolean(String
propertyName);
int hashCode();
String toString();
Static boolean valueOf(String
boolString);
Dua konstanta pada kelas ini yaitu Boolean.TRUE dan Boolean.FALSE.
Kelas
Character
Kelas ini membungkus tipe data dasar dan memiliki beberapa method :
static int digit(char ch, int radix);
contoh :
char ch1 = ’4’;
char ch2 = ’c’;
int four = Character.digit(ch1, 10); // hasilnya bil 4
int twelve = Character.digit(ch2, 12);
// hasilnya hexa c
static char forDigit(int digit, int radix);
contoh :
int i = 9;
char c = Character.forDigit(i, 10); //hasilnya
karakter ’9’
static boolean isDefined(char ch);
static boolean isDigit(char ch);
contoh :
boolean isDigit = Character.isDigit(’7’);
// hasilnya true
static boolean isIdentifierIgnorable(char ch);
static boolean isJavaIdentifierPart(char ch);
static boolean isLetter(char ch);
static boolean isLetterOrDigit(char ch);
static boolean isLowerCase(char ch);
contoh :
Character c = new Character(’g’);
boolean isLower = Character.isLowerCase(c); //
true
static boolean isSpace(char ch);
contoh :
boolean isSpace = Character.isSpace(’\t’);//hasilnya
true
static boolean isUpperCase(char ch);
static boolean isTitleCase(char ch);
static boolean isUnicodeIdentifierPart(char
ch);
static boolean isUnicodeIdentifierStart(char
ch);
static boolean isWhitespace(char ch);
static char toLowerCase(char ch);
contoh :
char ch = Character.toLowerCase(’M’);
System.out.println(ch); // hasilnya m
static char toTitleCase(char ch);
static char toUpperCase(char ch);
contoh :
char ch = Character.toUpperCase(’n’);
System.out.println(ch); // hasilnya N
Saat konversi dari numerik ke karakter atau sebaiknya,
kelas Character memiliki attribute yang bersifat static final (konstanta),
yaitu MIN_RADIX (basis 2) dan MAX_RADIX (basis 36).
Kelas Byte, Short, Integer, dan Long
Method-method di kelas Byte adalah :
byte byteValue(); // objek
kelas Byte menjadi nilai byte
//
membandingkan dua objek Byte secara numerik
int compareTo(Byte b);
int compareTo(Object obj);
static Byte decode(String str)
throws NumberFormatException
doubleValue(); // objek kelas
Byte menjadi nilai double
//
membandingkan dua objek milik kelas Byte
boolean equels(Object obj);
float floatValue();// objek
kelas Byte menjadi nilai float
int hashCode();
int intValue();// objek kelas
Byte menjadi nilai int
long longValue();// objek kelas
Byte menjadi nilai long
static byte parseByte(String str)
throws NumberFormatException
static byte parseByte(String str,
int radix) throws NumberFormatException
short shortValue();//objek
kelas Byte menjadi nilai short
String toString();
// konversi
nilai numerik menjadi objek milik kelas String
static String toString(byte num);
static Byte valueOf(String str)
throws NumberFormatException
static Byte valueOf(String str, int
radix) throws NumberFormatException
Method-method di kelas Short :
byte byteValue(); // objek
kelas Short menjadi nilai byte
//
membandingkan dua objek milik kelas Short secara numerik
int compareTo(Short sh);
int compareTo(Object obj);
static Short decode(String str)
throws NumberFormatException
//konversi objek
kelas Byte menjadi nilai double
daouble doubleValue();
//
membandingkan dua objek milik kelas Short
boolean equels(Object shortObj);
float floatValue(); // objek
kelas Short menjadi nilai float
int hashCode();
int intValue(); // objek kelas Short
menjadi nilai int
long longValue(); // objek
kelas Short menjadi nilai long
static byte parseShort(String str)
throws NumberFormatException
static byte parseShort(String str, int radix) throws
NumberFormatException
short shortValue(); //objek
kelas Short menjadi nilai short
// konversi
nilai numerik short menjadi objek milik kelas String
String toString(short num);
static Short valueOf(String str)
throws NumberFormatException
static Short valueOf(String str, int radix) throws NumberFormatException
Method-method di kelas Integer :
byte byteValue(); //objek kelas
Integer menjadi nilai byte
//
membandingkan dua objek milik kelas Integer secara numerik
int compareTo(Integer i);
int compareTo(Object obj);
static Integer decode(String str)
throws NumberFormatException
//objek milik
kelas Integer menjadi nilai double
double doubleValue();
//
membandingkan dua objek milik kelas Integer
boolean equels(Object IntegerObj);
//konversi objek
milik kelas Integer menjadi nilai float
float floatValue();
static Integer getInteger(String
propertyName);
static Integer getInteger(String
propertyName, int default);
static Integer getInteger(String
propertyName, Integer default);
static String toBinaryString(int
num);
static String toHexString(int num);
static String toOctalString(int
num);
int hashCode();
int intValue();//objek milik
kelas Integer menjadi nilai int
// konversi objek
milik kelas Integer menjadi nilai long
long longValue();
static byte parseInt(String str)
throws NumberFormatException
static byte parseInt(String str, int radix) throws NumberFormatException
// konversi objek
milik kelas Integer menjadi nilai short
short short()Value;
// konversi
nilai numerik short menjadi objek milik kelas String
String toString();
// konversi
nilai numerik int menjadi objek milik kelas String
static String toString(int num);
static String toString(int num, int
radix);
static Integer valueOf(String str)
throws NumberFormatException
static Integer valueOf(String str, int radix) throws
NumberFormatException
Dua attribute yang bersifat final static (konstanta) pada kelas Integer :
MINVALUE (nilai terkecil yg dapat
disajikan objek milik kelas Integer).
MAXVALUE (nilai terbesar yg dapat
disajikan objek milik kelas Integer).
Method-method di kelas Long adalah :
byte byteValue(); // objek
kelas Long menjadi nilai byte
//
membandingkan dua objek milik kelas Long secara numerik
int compareTo(Long obj);
int compareTo(Object obj);
static Long decode(String str) throws
NumberFormatException
//objek milik
kelas Long menjadi nilai double
double doubleValue();
//
membandingkan dua objek milik kelas Long
boolean equels(Object obj);
//konversi objek
milik kelas Long menjadi nilai float
float floatValue();
contoh :
Integer i = new Integer(17);
float f = i.floatValue(); //
hasilnya 17.0
static Long getLong(String
propertyName);
static Long getLong(String
propertyName, int default);
static Long getLong(String
propertyName, Integer default);
int hashCode();
int intValue(); // objek milik
kelas Long menjadi nilai int
// konversi objek
milik kelas Long menjadi nilai long
long longValue();
static
long parseLong(String str) throws NumberFormat Exception
static
long parseLong(String str, int radix) throws NumberFormat Exception
// konversi
objek milik kelas Long menjadi nilai short
short shortValue();
static String toBinaryString(long
num);
static String toHexString(long
num);
static String toOctalString(long
num);
// konversi
nilai numerik long menjadi objek milik kelas String
String toString();
Static String toString(long num);
static Long valueOf(String str)
throws NumberFormatException
static Long valueOf(String str, int
radix) throws NumberFormatException
Kelas Float dan Double
Method-method di kelas Float :
byte byteValue();
// objek kelas Float menjadi nilai byte
//
membandingkan dua objek milik kelas Float secara numerik
int
compareTo(Float f);
int
compareTo(Object obj);
//objek milik
kelas Float menjadi nilai double
double
doubleValue();
//
membandingkan dua objek milik kelas Float
boolean
equels(Object obj);
// konversi objek
milik kelas Float menjadi nilai float
float
floatValue();
int hashCode();
static float
intBitsToFloat(int bits); // bit biner ke float
static int
floatToIntBits(float num); //bil float ke bit biner
int intValue(); //
objek milik kelas Float menjadi nilai int
boolean
isInfinite();
static boolean
isInfinite(float f);
boolean isNaN();
static boolean
isNaN(float f);
// konversi objek
milik kelas Float menjadi nilai long
long longValue();
contoh :
Float f = new
Float(34.237);
long l =
f.longValue(); // hasilnya long 34
static
float parseFloat(String str) throws NumberFormatException
// konversi
objek milik kelas Float menjadi nilai short
short
shortValue();
// konversi
nilai numerik float menjadi objek milik kelas String
String toString();
static String
toString(float num);
static Float
valueOf(String str) throws NumberFormatException
Method-method di kelas Double :
// objek kelas Double menjadi nilai byte
byte byteValue();
//
membandingkan dua objek milik kelas Double secara numerik
int
compareTo(Double d);
int
compareTo(Object obj);
static int
doubleToLongBits(double num);
//objek milik
kelas Double menjadi nilai double
double
doubleValue();
//
membandingkan dua objek milik kelas Double
boolean
equels(Object obj);
// konversi objek
milik kelas Double menjadi nilai float
float
floatValue();
int hashCode();
int intValue(); //
objek milik kelas Double menjadi nilai int
boolean
isInfinite();
static boolean
isInfinite(double num); //num tak hingga
boolean isNaN();
static boolean
isNaN(double num); //NaN = not a number
staic double longBitsToDouble(long
num);
// konversi objek
milik kelas Double menjadi nilai long
long longValue();
static float
parseDouble(String str) throws NumberFormatException
// konversi
objek milik kelas Double menjadi nilai short
short
shortValue();
// konversi
nilai numerik double menjadi objek milik kelas String
String toString()
static String
toString(double num);
Kelas Float memiliki beberapa attribute yang bersifat
final dan static (konstanta) yaitu :
|
Nama Konstanta
|
Deskripsi
|
|
MINVALUE
|
Nilai
terkecil objek Float
|
|
MAXVALUE
|
Nilai terbesar
objek Float
|
|
NEGATIVE_INFINITY
|
Angka tak
berhingga negatif
|
|
POSITIVE_INFINITY
|
Angka tak
berhingga positif
|
|
NaN
|
Kondisi bukan
angka
|
Komentar
Posting Komentar