diktat oop mi politekniktelkom by jasman...

1

Created by JASMAN PARDEDE, S.Si, M.T

Prakata

Dengan penuh rasa syukur kepada Tuhan Yang Maha Kuasa akhirnya penulisan buku

ini dapat diselesaikan. Pada kesempatan ini penulis juga mengucapkan terima kasih yang sebesar-besarnya kepada beberapa pihak yang turut serta didalam penyelesaian buku ini, baik secara langsung maupun tidak langsung. Khususnya penulis mengucapkan terima kasih kepada :

1. Istriku tercinta, Eva Ellen Agustina Manurung, dan kedua anakku terkasih, Jeselline

Margareth Pardede dan Jesella Olivia Pardede, senyum kalian memotivasiku untuk

cepat menyelesaikan buku ini.

2. Ketua Jurusan dan segenap dosen Teknik Informatika Itenas Bandung yang memberikan

dukungan.

3. Mahasiswa-mahasiswa yang saya sayangi, yang memberikan bantuan secara tidak

langsung di dalam memberikan pemahaman tentang bagaimana cara dalam

memberikan penjelasan tentang konsep setiap materi.

4. Semua pihak yang tidak dapat penulis sebutkan satu per satu dalam proses pembuatan

buku ini.

Dengan senang hati, saya sampaikan penghargaan yang setinggi-tingginya atas kritik yang membangun dan bantuan saran-saran dari para pembaca demi kesempurnaan buku ini. Akhirnya, dengan segala kerendahan hati saya ucapkan terima kasih.

Bandung, September 2010

Jasman Pardede

2


Daftar Isi

Prakata ............................................................................................................................ 1 Daftar Isi ............................................................................................................................. 2

Mengenai Buku Ini ..................................................................................................... 5

Bab 1 Pendahuluan ............................................................................................................. 6 1.1 Pemrograman Berorientasi Objek ........................................................................... 7 1.2 Pengenalan Bahasa Java ....................................................................................... 10 1.3 Tata Bahasa Java ................................................................................................... 15

Soal Latihan Bab 1. ........................................................................................................... 21 Bab 2 Konsep Pemrograman Berorientasi Objek ............................................................. 22

2.1 Objek ....................................................................................................................... 22

2.2 Objek dan Interaksinya pada Dunia Nyata ............................................................. 23

2.3 Objek dan Interaksinya dalam Pemrograman ......................................................... 25

2.4 Pesan (Message)...................................................................................................... 26 2.5 Kelas (Class) ........................................................................................................... 28

Soal Latihan Bab 2. ........................................................................................................... 30 Bab 3 Object, Class, Message dan Method....................................................................... 31

3.1 Objects dan Class ................................................................................................... 31 3.2 Message dan Method ............................................................................................. 34 3.3 Method ................................................................................................................... 35 3.4 Penciptaan Objek .................................................................................................... 37

Soal Latihan Bab 3. ........................................................................................................... 41 Bab 4 Class dan Object pada Java .................................................................................... 42

4.1 Variabel dalam suatu Class ..................................................................................... 43 4.2 Method dalam suatu Class ...................................................................................... 45 4.3 Pengaksesan Variabel dan Method ......................................................................... 46 4.4 Pendefinisian Class ................................................................................................. 46 4.5 Pendefinisian Method ............................................................................................. 47 4.6 Variabel this ............................................................................................................ 51 4.7 Penggunaan Block Inisialisasi ................................................................................ 54 4.8 Constructors ............................................................................................................ 56 4.9 Overloading Method ............................................................................................... 59 4.10 Inheritance............................................................................................................. 59 4.11 super ...................................................................................................................... 63

4.12 Pengiriman method Dinamis................................................................................. 66 4.13 Kata kunci final ..................................................................................................... 68 4.14 Kata kunci static .................................................................................................... 71 4.15 Kata kunci finalize ................................................................................................ 73 4.16 Abstract ................................................................................................................. 74 4.17 Penggunaan Package ............................................................................................. 77 4.18 Antarmuka (Interface) ........................................................................................... 84

Soal Latihan Bab 4. ........................................................................................................... 89 Bab 5 Tipe-Tipe Data pada Java ....................................................................................... 90

5.1 Data dan Variabel ................................................................................................. 90

3


5.2 Nama Variabel ...................................................................................................... 90 5.3 Variabel dan Type ................................................................................................. 91 5.4 Tipe-Tipe Sederhana ............................................................................................. 92 5.5 Tipe Data Bentukan ............................................................................................ 103 5.6 Array .................................................................................................................... 108

Soal Latihan Bab 5. ......................................................................................................... 125 Bab 6 Operator pada Java ............................................................................................... 126

6.1 Operator Aritmatik ................................................................................................ 126 6.2 Operator Bitwise Integer ....................................................................................... 128 6.3 Operasi Relasi ....................................................................................................... 130 6.4 Operator Logika Boolean ...................................................................................... 130 6.5 Preseden Operator ................................................................................................. 132

Soal Latihan Bab 6. ......................................................................................................... 134 Bab 7 Pengaturan Alur Program ..................................................................................... 135

7.1 Pembuatan Keputusan ........................................................................................... 135 7.2 Pencabangan ......................................................................................................... 136 7.3 Pengulangan .......................................................................................................... 146

Soal Latihan Bab 7. ......................................................................................................... 162 Bab 8 Klasifikasi, Generalasasi dan Spesifikasi ............................................................. 163

8.1 Klasifikasi ............................................................................................................ 163 8.2 Hirarki Relasi antar Class ..................................................................................... 167 8.2.1 SuperClass dan SubClass ................................................................................... 167 8.2.2 Diagram Suatu Hirarki Class ............................................................................ 169 8.3 Generalisasi .......................................................................................................... 170 8.4 Spesifikasi ............................................................................................................ 172 8.5 Pengorganisasi Hirarki Class ............................................................................... 172 8.6 Class Abstract dan Class Konkrit ........................................................................ 173

Soal Latihan Bab 8. ......................................................................................................... 175 Bab 8 Eksepsi .................................................................................................................. 176

8.1 Dasar-dasar Penanganan Eksepsi .......................................................................... 177 8.2 Tipe-Tipe Eksepsi ............................................................................................... 177 8.3 Try dan catch......................................................................................................... 182 8.4 Pernyataan Catch Majemuk .................................................................................. 186 8.5 Pernyataan Try Bersusun ...................................................................................... 188 8.6 Pernyataan throw .................................................................................................. 192 8.7 Pernyataan throws ................................................................................................. 194 8.8 Pernyataan finally ................................................................................................. 196 8.9 Subclass Eksepsi ................................................................................................... 198

Soal Latihan Bab 8. ......................................................................................................... 202 Bab 9 Thread ................................................................................................................... 203

9.1 Thread pada Java................................................................................................... 203 9.2 Sinkonisasi Proses pada Java : Monitor .............................................................. 205 9.3 Pemrograman Multithreading pada Java .............................................................. 206

9.4 Pengontrolan Eksekusi Thread pada Java ............................................................. 207 Soal Latihan Bab 9. ......................................................................................................... 227 Bab 10 Graphical User Interface pada Java .................................................................... 228

4


10.1 Penciptaan Window ............................................................................................ 230 10.2 Components dan Containers ............................................................................... 233 10.3 Komponen Window dan Komponen Frame ....................................................... 234

10.4 Window Panes .................................................................................................... 235 10.5 Dasar-dasar Components .................................................................................... 236 10.6 Component Swing ............................................................................................... 237 10.7 Penggunaan Container ........................................................................................ 240 10.8 Container Layout Managers ................................................................................ 241 10.9 Proses Penanganan Event ................................................................................... 241 10.10 Penambahan Menu pada suatu Window ........................................................... 244

10.11 Penambahan Shortcut bagi suatu Menu Item.................................................... 244

Soal Latihan Bab 10. ....................................................................................................... 261 Bab 11 JDBC .................................................................................................................. 262

11.1 Package JDBC .................................................................................................... 262 11.2 Hubungan JDBC dengan ODBC ........................................................................ 263

11.3 InteractiveSQL Tool ........................................................................................... 269 11. 4 Pengertian Interface TabelModel ....................................................................... 270 11.5 Pemanggilan Procedure ...................................................................................... 270 11.6 Pengaturan Koneksi dengan ODBC.................................................................... 270

Soal Latihan Bab 11. ....................................................................................................... 296 Daftar Pustaka ................................................................................................................. 298

5


Mengenai Buku Ini

Buku ini ditulis berdasarkan hasil pengalaman penulis di dalam mengajarkan mata kuliah pemrograman berorientasi Objek selama kurang lebih dari 5 tahun baik di kampus maupun di tempat kursus dan juga dalam pengerjaan suatu proyek di konsultan IT. Dengan melihat berbagai karakter dan cara pandang mahasiswa di dalam memahami konsep objek, khusus dalam pemrograman berorientasi objek java, maka penulis mencoba untuk memberikan penjelesan tentang konsep objek pada Java secara jelas dan detail.

Setiap bab dalam buku ini dijelaskan secara detail dengan memberikan pemahaman konsep dan berbagai contoh-contoh yang berhubungan dengan topik yang dibahas, sehingga setiap bab akan dapat langsung dipahami oleh para pembaca. Setiap contoh listing code dijelaskan setiap baris, dan hasilnya diberikan dalam print screen kepada pembaca dan juga beberapa komentar khusus baik pada listing code atau pada print screen. Pada akhir setiap bab, juga diberikan latihan soal yang dapat membantu pembaca di dalam menggali pemahaman pembaca.

Dengan membaca setiap bab dari buku ini, maka penulis percaya bahwa pembaca akan menguasai konsep objek, konsep pemrograman berorientasi objek java, Class dan Objek pada Java, Tipe data dan Operator pada Java, Pengaturan alur program, Eksepsi, Thread, GUI, dan JDBC. Pada buku ini juga diberikan beberapa khusus yang aplikatif, seperti pembuatan aplikasi client-server sederhana yang dibahas pada contoh bab Thread. Pada buku ini juga diberikan pembuatan system informasi sederhana seperti yang dibahas pada JDBC.

6


Bab 1 Pendahuluan

Program adalah kumpulan data dan instruksi yang dapat dieksekusi pada suatu

bahasa tertentu. Program komputer adalah simulasi digital dari suatu model konseptual

atau fisik. Model-model ini sering kali menjadi sangat rumit, sehingga untuk

menghilangkan kerumitan ini diperlukan suatu program aplikasi yang dilakukan oleh

programmer. Kerja programmer bertujuan untuk memecahkan kerumitan tersebut

menjadi bentuk yang mudah dimengerti dan ditampilkan untuk para pemakai melalui

antarmuka.

Pada lingkungan pemrograman yang lama, membiarkan programmer memikirkan

program sebagai urutan perintah yang linier, model ini sering disebut model prosedural

atau berorientasi proses. Model berorientasi proses adalah suatu model yang memberikan

urutan langkah-langkah tunggal dalam suatu permasalahan tanpa memodelkan

keseluruhan masalah.

Model berorientasi proses baik untuk program yang sederhana, tetapi ketika

program bertambah besar, masalah akan banyak timbul, dimana kelambatan

mendefinisikan antarmuka atau interaksi antara hal-hal yang dikombinasikan dengan

sejumlah hal lain akan menjadi tak teratur dan kesalahan pun lebih sering terjadi.

Pada pemrograman berorientasi objek, kerumitan suatu permasalahan diatur

dengan membuat abstraksi. Sebagai contoh, kita tidak melihat mobil sebagai susunan

puluhan ribu komponen. Kita melihatnya sebagai objek-objek tertentu dengan sifat

uniknya. Dengan abstraksi ini kita dapat berangkat ke toko onderdil tanpa dibingungkan

dengan algoritma untuk menjelaskan bagaimana mesin, transmisi, dan sistem rem

bekerja. Sebaliknya kita diberikan suatu gambaran yang cukup jelas dan ideal, tentang

bagaimana objek-objek bekerja. Dengan demikian kita dapat melihat sebagai suatu

gambaran yang cukup jelas dan ideal untuk menjelaskan bagaimana keseluruhan objek

bekerja.

Kita mempunyai kemampuan yang kuat untuk mengatur gambaran ini secara

hirarkis yang memungkinkan kita untuk melihat lebih dalam mengenai mobil itu jika kita

menginginkannya. Dari luar, mobil adalah mobil, lalu sedikit lebih dalam, kita dapat

7


mengoperasikan setir, rem, stereo-set, sabuk pengaman, AC, dan telepon seluler secara

bersamaan.

Cara berpikir seperti ini mengambarkan (abstraksi) secara hirarkis sistem yang

rumit menjadi lebih sederhana. Kita mengamati suatu objek menjadi bagian-bagian objek

yang lebih konkrit dengan perlakuannya masing sampai kita mendapatkan objek yang

paling sederhana. Hal ini juga yang diterapkan dengan baik pada program komputer dan

kehidupan nyata. Algoritma program tradisional dapat digambarkan dalam bentuk objek

komponen yang berkaitan dengan proses. Urutan proses dapat menjadi kumpulan pesan

antar objek yang otonom. Setiap objek memiliki perilaku yang unik. Kita memperlakukan

objek ini sebagai kejadian dunia-nyata yang konkrit dan merespon pesan yang

disampaikan padanya untuk melakukan sesuatu. Inilah esensi dari pemrograman

berorientasi objek. Kita melengkapi objek kita dengan ‘kepribadian’ dan percaya bahwa

mereka akan selalu berkelakuan menurut spesifikasi yang telah dibuat.

1.1 Pemrograman Berorientasi Objek

Pemrograman berorientasi objek sangat ampuh dan merupakan paradigma alami

untuk membuat program yang dapat bertahan terhadap kemungkinan perubahan yang

berkaitan dengan pertumbuhan dan pertambahan umur sistem apapun. Karena kita telah

memahami fungsi masing-masing objek dan memiliki antar muka yang jelas dan layak

antar objek, kita dapat mengatur ulang bagian-bagian dari sistem yang lama tanpa takut-

takut. Dalam pemrograman berorientasi objek setiap permasalahan pertama kali dibuat

dalam bentuk paling abstrak, baru kemudian mendefinisikan subrutin yang berkaitan

dengan implementasi yang lebih konkrit, dan juga kita harus mengusahakan untuk

menghindari penggunaan variabel global dan melewatkan suatu pointer ke dalam suatu

struktur.

Bahasa berorientasi objek sejati menyediakan mekanisme yang dikenal sebagai

enkapsulasi, inheritansi, dan polimorfisme. Baik C++ maupun Java menyertakan

mekanisme ini dengan cara yang hampir sama. Pada subbab berikut ini kita akan

membahas pengertian masing-masing mekasnime serta bagaimana konsep tersebut

diimplementasikan pada pemrograman Java.

8


1.1.1 Enkapsulasi Enkasulasi dapat dipikirkan sebagai bungkusan (wrapper) pelindung program dan

data yang sedang diolah. Pembungkus ini mendefinisikan perilaku dan melindungi

program dan data agar tidak diakses sembarangan oleh program lain. Contoh dalam dunia

nyata, transmisi otomatis pada mobil mengenkapsulasi ribuan keping informasi dari

mesin, seperti percepatan, kemiringan tanjakan, dan posisi perseneling.

Pada Java, dasar enkapsulasi adalah class. Kita membuat suatu class yang

menyatakan abstraksi dari sekolompok objek yang berbagi struktur dan sifat yang sama.

Objek adalah keadaan tertentu suatu class yang mempertahankan struktur dan sifat

sebagaimana didefinisikan oleh class tersebut, seolah-olah keluar dari cetakan class yang

sama. Objek-objek ini sering disebut sebagai instans dari class. Struktur tertentu atau

representasi data dari suatu class didefinisikan oleh sekumpulan variabel instans.

Variabel-variabel ini menyimpan keadaan dinamis setiap instans suatu class. Sifat dan

antarmuka suatu class didefinisikan dengan method yang beroperasi pada data instans

tersebut. Method adalah perintah untuk melakukan beberapa aksi terhadap sebuah objek.

Karena tujuannya mengenkapsulasi kerumitan, ada mekanisme untuk

menyembunyikan kerumitan implementasi dalam class. Setiap method atau variabel

dalam class dapat jadi private, protected atau public. Antarmuka public suatu class

menunjukkan semua yang perlu terhadap class tersebut dapat mengaksesnya. Suatu

method atau data instans private menyatakan bahwa program lain di luar implementasi

class tidak dapat mengakses method atau data dari class tersebut. Antarmuka protected

suatu class menunjukkan bahwa semua class yang merupakan class turunannya dapat

mengakses method atau data dari classnya, tetapi class lain yang bukan class turunan

tidak dapat mengakses method atau data dari classnya. Antarmuka public harus dipilih

dengan hati-hati supaya tidak terlalu banyak membuka bagian dalam class.

Perbedaan antara class dengan instans adalah :

1. Class adalah sesuatu yang menjelaskan attribut dan umum sebuah objek, termasuk

tipe setiap attribut method yang dapat mengoperasikan objek tersebut.

2. Sebuah instans adalah keadaan tertentu sebuah objek tersebut.

9


Contoh seekor anjing Labrador mempunyai enam anak, maka dia membuat enam instans

baru dari class Labrador. Setiap anak anjing memiliki himpunan variabel instansi-nya

sendiri yang didefinisikan dengan class. Beberapa hitam, yang lain coklat, dan sisanya

putih, beberapa jantan, yang lain betina, tetapi semuanya tetap Labrator.

1.1.2 Inheritansi Sebagian besar kita melihat lingkungan kita sebagai objek yang saling terhubung

secara hirarkis, misalkan binatang, mamalia, dan anjing. Jika kita amati binatang

memiliki ciri-ciri tertentu, misalkan ukuran, kecerdasan, dan jenis sistem kerangka

tulangnya. Binatang juga memiliki aspek prilaku tertentu, mereka makan, bernafas, dan

tidur. Penjelasan struktur tubuh dan prilaku ini adalah penjelasan class binatang.

Jika kita ingin menjelaskan lebih terinci suatu class binatang, misalkan mamalia,

maka harus dirinci ciri-ciri lain, misalkan jenis gigi dan periode kehamilan. Ini dikenal

sebagai sub-class binatang, dimana binatang adalah super class mamalia.

Karena mamalia dikelompokkan sebagai binatang, maka mamalia mewarisi

(inherit) semua ciri-ciri binatang. Inheritansi juga berinteraksi dengan enkapsulasi. Jika

suatu class tertentu mengenkapsulasi sejumlah attribut, maka sub-class manapun akan

memiliki attribut yang sama ditambah dengan attribut spesialisasinya.

1.1.3 Polimorfisme Method pada objek adalah informasi yang dilewatkan sebagai parameter untuk

permintaan method. Parameter ini mewakili nilai yang dimasukkan ke suatu fungsi dan

harus dikerjakan oleh suatu method.

Polimorfisme, yang berarti satu objek dengan banyak bentuk, adalah konsep

sederhana yang memperbolehkan method memiliki beberapa implementasi yang dipilih

berdasarkan tipe objek yang dilewatkan pada pengerjaan metode. Ini dikenal sebagai

overloading method.

1.1.4 Overriding Overloading sebuah method adalah cara class tunggal mengurusi tipe yang berbeda

dengan cara yang seragam. Cara tersebut statik karena implementor suatu class perlu

mengetahui semua type yang akan dihadapinya agar dapat menulis suatu metode.

10


Pembuatan sub-class memungkinkan kita untuk menggunakan polimorfisme pada

program yang sedang berjalan secara lebih dinamis.

1.2 Pengenalan Bahasa Java

Java sebagai salah satu bahasa pemrograman baru menjanjikan banyak kemudahan

bagi programer junior maupun senior. Bab ini akan membawa kita mengenal lebih jauh

tentang bahasa Java melalui pembahasan konsep model perancangan dan petunjuk

penggunaannya.

Java adalah bahasa pemrograman berorientasi objek yang dikembangkan oleh Sun

Microsystems sejak tahun 1991. Bahasa ini dikembangkan dengan model yang mirip

dengan bahasa C++ dan Smalltalk, namun dirancang agar lebih mudah dipakai dan

platform independent, yaitu dapat dijalankan di berbagai jenis sistem operasi dan

arsitektur komputer. Bahasa ini juga dirancang untuk pemrograman di Internet sehingga

dirancang agar aman dan portabel.

Platform independent berarti program yang ditulis dalam bahasa Java dapat dengan

mudah dipindahkan antar berbagai jenis sistem operasi dan berbagai jenis arsitektur

komputer. Aspek ini sangat penting mengingat tujuan awal Java sebagai bahasa

pemrograman Internet dimana sebuah program akan dijalankan oleh berbagai jenis

komputer dengan berbagai jenis sistem operasi. Sifat ini berlaku untuk level source code

dan binary code dari program Java. Berbeda dengan bahasa C dan C++, semua tipe data

dalam bahasa Java mempunyai ukuran yang konsisten di semua jenis platform. Source

code program Java sendiri tidak perlu dirubah sama sekali jika kita ingin meng-compile

ulang di platform lain. Hasil dari meng-compile source code Java bukanlah kode mesin

atau instruksi prosesor yang spesifik terhadap mesin tertentu, melainkan berupa bytecode

yang berupa file berekstensi .class. Bytecode tersebut dapat langsung kita eksekusi di tiap

platform dengan menggunakan Java Virtual Machine (JVM) sebagai interpreter terhadap

bytecode tersebut.

JVM sendiri adalah sebuah aplikasi yang berjalan di atas sebuah sistem operasi dan

menerjemahkan bytecode program Java dan mengeksekusinya, sehingga secara konsep

bisa dianggap sebagai sebuah interpreter. Sehingga dengan adanya JVM maka sebuah

program Java yang telah dikompilasi akan dapat berjalan di platform mana saja.

11


File program sumber Java, resminya disebut unit kompilasi (compilation unit),

adalah suatu file teks yang berisi satu atau lebih definisi class. Compiler java memerlukan

file-file ini untuk disimpan dalam file dengan akhiran .java. Ketika program sumber Java

di compile, setiap class diletakkan pada file keluaran masing-masing dengan akhiran

.class.

Contoh 1.1

/* * Nama File : HelloWord.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1. class HelloWorld {

2. public static void main(String[] args){

3. System.out.println("Hello World, Nice to meet you all");

4. }

5. }

Penjelasan langkah demi langkah :

Meskipun HelloWorld hanya suatu contoh sederhana, namun ia cukup menarik dalam

meperlihatkan pemrograman baru ini untuk pertama kali, karena perlu memperkenalkan

konsep dan perincian sintaks sekaligus, seperti yang dijelaskan berikut ini :

1. Baris 1, class HelloWorld {

menggunakan kata simpanan class untuk mendeklarasikan bahwa sebuah class baru

akan didefinisikan di sini. HelloWorld adalah sebuah identifier yang dapat

digunakan, akan kita gunakan untuk mengidentifikasi class. Seluruh definisi class,

termasuk semua program dan data, akan ada di antara tanda kurung-kurawal-buka

‘ {‘ dan pasangannya, kurung-kurawal-tutup ‘}’, yaitu pada baris 5.

2. Baris 2, public static void main(String[] args){

Baris kedua program sederhana ini menjadi rumit, karena rancangan Java yang

sama sekali tidak memperbolehkan adanya variabel global, hanya boleh ada class.

Untuk lebih detailnya konsep ini, akan kita lihat per detailnya.

3. public

12


ini adalah ketentuan akses, yang mengizinkan programmer mengendalikan

visibilitas setiap variabel atau metode. Pada kasus ini, public menunjukkan bahwa

sembarang class dapat melihat method main.

4. static

method dan variabel yang digunakan oleh class, berlawanan dengan instans class

tersebut, dapat dideklarasikan static. Ini memungkinkan sebuah method dipanggil

tanpa harus menjadi instans suatu class. Pada kasus main, perlu dideklarasikan

static karena main dipanggil oleh interpreter sebelum instans dibuat.

5. void

karena pada contoh ini hanya menuliskan ke layar dan tidak menghasilkan suatu

besaran, jadi digunakan void.

6. main

Java sangat memperhatikan besar-kecil huruf (case-sensitive) bila berkaitan dengan

kata kunci dan identifier. Jadi Main berbeda dengan main. Tidak ada yang

istimewa dengan main, kecuali bahwa implementasi interpreter Java saat ini akan

mencari method dengan nama main ketika meng-interpretasi suatu class. Compile

Java akan meng-compile class-class yang tidak memiliki method main. Akan

tetapi, interpreter Java, tidak memiliki cara untuk menjalankan class-class tersebut.

Method main secara sederhana merupakan titik awal untuk kerja interpreter.

Program yang rumit akan memiliki lusinan class, hanya satu diantaranya yang harus

memiliki method main agar program dapat berjalan. Untuk program Java yang

berjalan di web, kita tidak akan membuat method main sama sekali, karena

jalannya program web browser Java memiliki aturan yang berbeda untuk memulai

jalannya applet.

7. (String[] args)

semua parameter yang dilewatkan ke suatu method diletakkan dalan tanda kurung”(

“ dan “)”. Jika tidak ada parameter yang dibutuhkan untuk method yang diberikan,

kita tetap harus menambahkan pesangan tanda kurung “( )”. Dalam contoh ini ada

satu parameter yang diberikan. String[] args, mendeklarasikan parameter yang diberi

nama args, yang merupakan array instans dari class String.

8. System.out.println("Hello World, Nice to meet you all");

13


method ini mengeksekusi method println pada out, yang merupakan instans

OutputStream dan secara statis diinisialisasi pada class System.

Untuk mengcompile file java yang telah kita buat cukup dengan

javac namafile.java

Untuk mengcompile file java pada contoh 1.1 cukup dengan

javac HelloWord.java

seperti yang ditunjukkan pada gambar 1.1 dibawah ini.

Gambar 1.1 Compile file Java

Nama file hasil compile-an mengikuti nama class yang ada dalam source code kita, jika

nama class-nya HelloWord maka akan dihasilkan HelloWord.class, seperti yang

ditunjukkan pada gambar 1.1. Untuk menjalankan program yang telah dicompile cukup

java namaclass

Jika kita kita mengeksekusi dengan java namaclass.class maka akan menghasilkan

pesan error. Untuk menjalankan file class HelloWord yang telah kita compile cukup

dengan,

java HelloWord

Sehingga akan menghasilkan seperti yang ditunjukkan pada gambar 1.2.

14


Gambar 1.2 Tampilan eksekusi bytecode file class HelloWord

Gambar 1.3 Text editor Eclipse

Untuk membuat source code dengan bahasa Java kita bisa menggunakan

program-program TextEditor seperti notepad, wordpad, TextPad, context, vi, dll. Bila

Saudara kesulitan, Saudara bisa menggunakan program-program IDE (Integrated

Development Environtment) seperti Eclipse, NetBeans, JCreator, JBuilder. Gambar 1.3

merupakan text editor Eclipse dan gambar 1.4 merupakan text editor NetBeans versi 6.8.

15


Gambar 1.3 Text editor NetBeansIDE 6.8

Untuk saat ini Saudara telah mempunyai gambaran tentang bagaimana proses

pembuatan program Java secara sederhana dalam bentuk aplikasi biasa. Saudara juga

dapat mencoba mengembangkan program sederhana tersebut sesuai dengan keinginan

Saudara berdasarkan hal-hal yang sudah Saudara ketahui. Konsep dasar yang sudah

Saudara dapatkan akan dikembangkan lebih lanjut dalam bab-bab selanjutnya. Selamat

mencoba!

1.3 Tata Bahasa Java

Pada sub bab di atas kita telah membahas program sederhana java. Pada sub bab ini

kita akan membahas tata bahasa program Java. Program Java adalah kumpulan spasi,

komentar, identifier, literal, operator, dan pemisah.

1.3.1 Spasi kosong

16


Java adalah bahasa bebas-bentuk. Tidak perlu mengatur tata letak agar dapat

bekerja. Asal selalu ada sekurang-kurangnya satu spasi, tab atau baris baru di antara

setiap token sebelum disisipi operator atau pemisah yang lain.

Contoh 1.2 dan Contoh 1.3 merupakan penulisan lain dari Contoh 1.1

Contoh 1.2

/* * Nama File : HelloWorld.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

class HelloWorld { public static void main(String[] args){

System.out.println("Hello World, Nice to meet you all"); } }

Contoh 1.3

class

HelloWorld

{

public

static

void

main

(

String

[

]

args

)

{

System.

out.

println

(

"Hello World, Nice to meet you all"

17


)

;

}

}

1.3.2 Komentar Biarpun komentar tidak berperan apapun pada jalannya program, jika digunakan

dengan benar dapat menjadi bagian penting dari setiap program. Komentar berperan

penting di dalam memberikan pengingat tentang apa yang akan dikerjakan oleh program

yang akan kita buat. Untuk program sederhana, komentar mungkin tidak begitu berperan,

karena kita masih dapat mengingat apa yang akan dikerjakan oleh algoritma program.

Untuk program yang cukup besar dan jika terjadinya penggantian programmer di dalam

melanjutkan program yang kita buat, maka komentar yang akan menjelaskan atau

menunjukkan tentang maksud dari algoritma program kita. Komentar pada program

sumber dapat dibuat dalam beberapa bentuk, yaitu baris-tunggal, yang dimulai dengan

“//” seperti yang diberikan pada contoh 1.4 atau komentar lebih dari satu baris, yang

dimulai dengan “/*” dan diakhiri dengan tanda “*/” seperti yang diberikan pada conoth

1.5.

Contoh 1.4 Komentar baris-tunggal

a = 42 ; // jawabanya 42

Contoh 1.5 Komentar banyak-baris yang lebih panjang.

/* * ini contoh komentar banyak baris * yang diperuntukkan sebagai pengingat */

1.3.3 Kata kunci Simpanan Kata kunci simpanan adalah identifier khusus yang disimpan oleh Java untuk

mengendalikan bagaimana program didefinisikan. Kata kunci ini digunakan untuk

mengenali tipe-tipe, pengubah, dan mekanisme pengaturan aliran program yang sudah

ada. Kata kunci hanya dapat digunakan untuk fungsi tertentu dan tidak dapat digunakan

sebagai identifier nama suatu variabel, class atau method. Diantara kata kunci yang

18


disimpan oleh Java dapat kita lihat pada tabel 1.1. Dalam penggunaan kata kunci

simpanan Java dapat kita lihat pada contoh 1.6.

Tabel 1.1 kata kunci simpanan Java

abstract boolean break byte byvalue

case cast catch char class

else extends false final finally

float for future generic goto

if implements import inner instanceof

int interface long native new

null operator outer package private

protected public rest return short

static super switch synchronized this

throw throws transient true try

var void volatile while

Contoh 1.6.

public int _sum = 0; // menggunakan kata kunci public dan int

1.3.4 Identifier Identifier digunakan untuk nama class, method, dan variabel. Suatu identifier

dapat urutan huruf (besar ataupun kecil), angka, garis bawah, dan tanda dollar. Tidak

boleh diawali dengan literal numerik. Java sangat memperhatikan besar-kecil-nya huruf

(case sensitive). Berikut ini merupakan contoh identifier yang berlaku; nimMhs, sumMK,

_ipk. Aturan penamaan identifier untuk semua method public dan variabel instans selalu

mengikuti huruf awal kecil dan bagian kata selanjutnya dengan huruf besar. Misalkan

getName, getTotalMhs.

Aturan penamaan untuk variabel private dan lokal semuanya huruf kecil dan

dikombinasikan dengan garis bawah. Misalkan i, next_record, tmp_buffer. Sedangkan

identifier variabel static yang mewakili suatu konstanta, semuanya huruf besar. Misalkan

PHI, RED.

1.1.1 Literal

19


Besaran konstanta pada Java dihasilkan dengan menggunakan literal yang

mewakilinya. Misalnya, Integer, boolean, karakter, string dll. Setiap literal memiliki tipe

yang berhubungan dengannya. Sutau literal merepresentasikan nilai suatu tipe, dimana

tipe itu sendiri menjelaskan bagaimana sifat nilai tersebut dan bagaimana

penyimpananya. Pada bab 4 akan kita akan membahas tipe data pada Java secara detail.

1.3.5 Operator

Operator adalah sesuatu yang membutuhkan satu argumen atau lebih dan bekerja

pada argumen tersebut untuk menghasilkan sesuatu. Pada bab 4 kita akan membahas

operator pada Java secara detail.

1.3.6 Pemisah (Separator) Hanya ada beberapa urutan karakter lain yang secara sintaks dapat diletakkan

pada program Java. Pada tabel 1.2 dijelaskan beberapa pemisah sederhana yang

mendefinisikan bentuk dan fungsi program yang dibuat.

Tabel 1.2 pemisah pada Java

Simbol Nama Penggunaan ( ) Kurung Digunakan untuk menghimpun parameter dalam definisi dan pemanggilan

method, juga digunakan untuk menyatakan tingkatan pernyataan, menghimpun pernyataan untuk pengaturan alur program, dan menyatakan tipe cast

{ } Kurung kurawal

Digunakan untuk menghimpun nilai yang otomatis dimasukkan ke dalam array, juga digunakan untuk mendefinisikan blok program, untuk cakupan class, method, dan lokal.

[ ] Kurung siku

Digunakan untuk menyatakan tipe array, juga digunakan untuk membedakan nilai array

; Titik koma Pemisah Pernyataan , Koma Pemisah urutan identifier dalam deklarasi variabel, juga digunakan untuk

mengaitkan pernyataan di dalam pernyataan for . Titik Digunakan untuk memisalahkan nama paket dari sub-paket dan class, juga

digunakan untuk memisahkan variabel atau method dari variabel refensi.

1.3.7 Variabel Variabel adalah satuan dasar penyimpanan dalam program Java. Suatu variabel

didefinisikan dengan kombinasi identifier, tipe, dan cakupan. Pendeklarasian variabel

dapat bersifat lokal atau sementara, atau variabel instan yang dapat diakses oleh semua

method dalam class.

20


Bentuk dasar deklarasi variabel adalah sebagai berikut :

type identifier [= value] [, identifier [=value] . . .] ;

type diisi dengan literal, nama class atau antarmuka. Value adalah sembarang nilai literal

atau pernyataan yang menghasilkan sesuatu nilai yang sama atau cocok dengan type.

Contoh 1.7:

int i, j, k; // mendeklarasikan tiga buah type int dengan identifier i, j, k

double PHI = 3.14159 // mendeklarasikan type double dengan identifier PHI

21


Soal Latihan Bab 1. 1. Apa yang dimasuksud dengan program?

2. Apa yang dimasuksud dengan pemrograman berorientasi objek?

3. Jelaskan kelebihan yang dimiliki oleh pemrograman berorientasi objek.

4. Apa yang dimaksud dengan objek dan class?

5. Jelaskan apa yang dimasuk dengan Enkapsulasi.

6. Jelaskan apa yang dimaksud dengan Inheritans.

7. Jelaskan apa yang dimaksud dengan Polimorfisme.

8. Jelaskan apa yang dimaksud dengan Overriding.

9. Jelaskan apa yang dimaksud dengan Java adalah bebas bentuk.

10. Apa yang dimaksud dengan kata kunci simpanan dan berikan contohnya.

11. Apa yang dimaksud dengan Identifier dan berikan contohnya.

12. Apa yang dimaksud dengan Literal dan berikan contohnya.

13. Apa yang dimaksud dengan Operator dan berikan contohnya.

14. Apa yang dimaksud dengan variable dan berikan contoh pendeklarasian variabel.

15. Buatlah listing code java sederhana untuk menampilkan informasi “Selamat belajar OOP

Java”.

22


Bab 2 Konsep Pemrograman Berorientasi Objek

Pemrograman berorientasi objek diciptakan untuk mempermudah pengembangan

program dengan cara mengikuti model yang telah ada dalam kehidupan nyata. Dalam

paradigma ini, sesuai dengan model kehidupan nyata, segala bagian (entiti) dari suatu

permasalahan adalah objek. Objek-objek ini kemudian dapat berupa gabungan dari

beberapa objek yang lebih kecil. Sebagai contoh, sebuah mobil. Mobil adalah sebuah

objek dalam kehidupan nyata. Namun mobil sendiri terbentuk dari beberapa objek yang

lebih kecil seperti roda ban, mesin, jok, transmisi, sistem rem, dan lain-lain. Mobil

sebagai objek yang merupakan gabungan dari objek yang lebih kecil dibentuk dengan

membentuk hubungan antara objek-objek penyusunnya. Begitu juga dengan sebuah

program. Objek besar dapat dibentuk dengan menggabungkan beberapa objek-objek

dalam bahasa pemrograman. Objek-objek tersebut berkomunikasi dengan saling

mengirim pesan kepada objek lain.

Konsep-konsep pemrograman berorientasi objek dalam Java secara umum sama

dengan yang digunakan oleh bahasa-bahasa lain. Jadi kebanyakan konsep yang kita bahas

juga terdapat dalam bahasa selain Java. Namun, terkadang terdapat perbedaan-perbedaan

kecil antara penerapan konsep-konsep tersebut dalam masing-masing bahasa. Perbedaan-

perbedaan ini juga akan dijelaskan seiring penjelasan masing-masing konsep.

2.1 Objek

Dalam penjelasan mengenai analogi, kita sudah menyinggung mengenai objek.

Sekarang kita akan mengupas lebih dalam tentang objek sebagai konsep kunci dari

pemrograman berorientasi objek.

Baik dalam dunia nyata atau dalam sebuah program, sebuah objek memiliki dua

karakteristik, yaitu state dan behaviour. State adalah keadaan dari sebuah objek, seperti

mobil memiliki state warna, model, tahun pembuatan, kondisi, dan lain-lain. Sedang

behaviour adalah kelakuan dari objek tersebut, seperti mobil dapat melaju, membelok,

membunyikan klakson, dan lain-lain. Objek menyimpan statenya dalam satu atau lebih

variabel, dan mengimplementasikan behaviournya dengan method. Dengan penjelasan di

23


atas, dapat disimpulkan bahwa objek adalah bagian software yang dibentuk dengan

variabel-variabel dan method-method yang berhubungan dengan variabel tersebut.

Dengan karakteristik tersebut, kita dapat memodelkan berbagai objek dalam

kehidupan nyata ke dalam objek-objek dalam sebuah program. Lebih lanjut kita dapat

memodelkan objek-objek abstrak ke dalam sebuah program. Contoh umum untuk konsep

abstrak seperti ini adalah objek Event, yaitu objek untuk mewakili peristiwa klik atau

tombol ditekan.

Sebuah objek yang dibentuk dari sebuah kelas biasa disebut instans dalam

terminologi pemrograman berorientasi objek (Object Oriented Programming –OOP).

Artinya objek tersebut adalah wujud nyata dari sebuah kelas. Variabel dan method dari instans

ini disebut variabel instans dan method instans. Setiap instans menyimpan variabelnya

sendiri-sendiri, jadi nilai variabel untuk tiap instans bisa berbeda.

2.2 Objek dan Interaksinya pada Dunia Nyata

Misalkan terdapat dua orang, Jasman dan anaknya, Jeselline. Mereka adalah

pembeli pada suatu toko buku saat mereka sedang membeli buku. Toko buku menjual

beberapa jenis buku. Setiap buku dikelompokkan atas beberapa jenis berdasarkan

kategori buku, yaitu novel, majalah, cerita anak-anak, buku pemrograman, buku

perkantoran dan lain sebagainya. Setelah melihat buku-buku yang ada di toko buku,

Jasman dan Jeselline memutuskan untuk membeli buku pemrograman berorientasi objek

karangan Pardede sebanyak 2 buah. Mereka meminta Anton, seorang sales yang ada pada

toko buku tersebut, untuk melayani pesanan yang hendak mereka beli.

Saat Jasman memintak layanan kepada Anton, Jasman mengirimkan suatu

message (pesan), “Saya hendak membeli buku pemrograman berorientasi objek karangan

Pardede sebanyak 2 buah. Dapatkah Saudara membuatkan faktur pembayarannya?”.

Message yang Jasman mintak kepada Anton adalah suatu pesan makeBilling.

Pesan tersebut mengandung informasi tentang tipe dari buku (yaitu pemrograman

berorientasi objek karangan Pardede, sebanyak 2 buah) dan tanggal pembelian buku

tersebut. Informasi ini dikenal dengan istilah parameter dari message makeBilling.

Untuk menanggapi permintaan Jasman, Anton memberikan layanan kepada

Jasman berupa hasil pembuatan faktur pembayaran atas nama Jasman. Kita dapat

24


merepresentasikan interaksi antara Jasman dan Anton seperti yang ditunjukkan pada

gambar 2.1.

Gambar 2.1 Interaksi antara Jasman dan Anton

Anton dapat melayani Jasman untuk membuat faktur pembayaran atas nama

Jasman, karena Anton mengerti bagaimana membuat faktur pembayaran. Tetapi karena

Jasman bukan seorang penjual pada toko buku tersebut, maka Jasman tidak boleh

membuat faktur pembayaran. Pada beberapa keadaan tertentu, seorang pembeli tidak

dapat memperoleh faktur pembayaran yang dia minta dari seorang penjual, melainkan

mendapatkan informasi, “maaf stok buku pemrograman berorientasi objek karangan

Pardede tinggal satu” atau “CD source code pemrograman berorientasi objek saat ini

sudah habis, jadi CDnya dapat Saudara ambil satu minggu setelah pembelian buku ini,

terima kasih untuk pembeliannya”.

Anton, sebagai seorang penjual, bertanggung jawab terhadap layanan yang akan

dia berikan terhadap Jasman. Anton dapat memberikan layanan kepada pembeli dengan

menerapkan sekumpulan operasi berikut :

1. Dia menentukan jika stok buku yang diminta oleh Jasman dapat dipenuhi.

2. Dia menentukan bahwa pembuatan faktur pembelian atas nama Jasman dapat

dilakukan.

3. Dia menentukan jumlah stok buku yang ada di toko.

4. Dia menentukan bahwa stok CD source code masih ada atau tidak.

5. Dia menentukan kapan bisa mengambil CD source code.

6. Akhirnya, dia memberikan informasi kepada Jasman, sebagai pembeli, layanan

apa yang diberikan kepada Jasman.

Jasman Anton makeBilling

result

25


2.3 Objek dan Interaksinya dalam Pemrograman

Interaksi antara Jasman dan Anton pada simulasi disubbab 2.2 dapat

direpresentasikan pada pemrograman berorientasi objek. Dimana, Jasman dan Anton

merupakan objek-objek yang berinteraksi dengan pengiriman pesan. Jasman adalah

sebuah objek yang mengirimkan pesan (messgae-sending object), sedangkan Anton

adalah sebuah objek yang menerima pesan (message-receiving object). Secara alternatif,

kita dapat melabeli Jasman sebagai pengirim (sender) dan Anton sebagai penerima

(receiver).

Permintaan makeBilling dari Jasman ke Anton merupakan suatu contoh dari

suatu message. Anton dapat meresponi permintaan Jasman jika message yang dikirimkan

Jasman kepada Anton merupakan suatu message yang valid. Setiap message yang valid

berhubungan dengan suatu method yang Anton dapat kerjakan guna memenuhi

permintaan Jasman.

Sebaliknya, suatu method yang tidak valid adalah suatu method dimana penerima

tidak memiliki kemampuan untuk mengerjakan permintaan pengirim. Sebagai contoh,

jika Jasman meminta Anton untuk memberikan discount 50 %, dimana Anton tidak

mempunyai hak untuk memberikan discount, maka Anton akan menolok permintaan dari

Jasman.

Suatu method memuat sekumpulan operasi yang berhubungan dengan bagaimana

Anton dapat memenuhi permintaan Jasman. Semua operasi yang Anton dapat lakukan

diberikan pada Anton dan Jasman hanya dapat meminta Anton melakukan pekerjaannya

sesuai dengan operasi yang dimiliki oleh Anton. Interaksi antar objek ini

direpresentasikan seperti pada Gambar 2.2.

Gambar 2.2 Interaksi antar Objek dalam Pemrograman Berorientasi Objek

Pada Gambar 2.2 dapat kita simpulkan bahwa Jasman dapat meminta Anton untuk

melakukan permintaannya, asalkan Jasman mengetahui bahwa Anton memiliki

Jasman Anton

Object Object

result

makeBilling(buku type, jumlah, namaPembeli, tglBeli)

message

method

arguments

26


kemampuan untuk melakukannya tanpa harus perlu mengetahui bagaimana Anton akan

melayani permintaannya. Ini merupakan suatu prinsip penting di dalam pemrograman

berorientasi objek, yang dikenal dengan istilah penyembunyian informasi (information

hiding) : pengirim suatu message tidak mengetahui bagaimana suatu penerima akan

melayani permintaannya.

2.4 Pesan (Message)

Objek-objek yang bekerja sama membentuk suatu sistem harus saling

berkomunikasi untuk menjalankan sistem tersebut. Dalam sebuah program, objek-objek

berkomunikasi satu sama lain dengan mengirimkan pesan. Sebagai contoh, jika sebuah

objek ingin memanggil method dari objek lain, maka objek ini akan mengirimkan sebuah

pesan yang meminta objek tujuan untuk menjalankan method yang dikehendaki. Pesan

ini akan berisi informasi-informasi yang dibutuhkan objek tujuan untuk dapat melayani

permintaannya. Sebuah pesan dibentuk oleh informasi berikut ini:

1. objek yang dituju, yaitu nama class yang meng-instansiasi objek yang dimaksud.

2. nama method yang ingin dipanggil, yaitu apa method yang dimiliki oleh objek yang

ingin kita gunakan. Dalam hal ini, kita harus mengetahui method yang dimiliki oleh

class yang meng-instansiasi objek yang hendak kita gunakan.

3. parameter yang dibutuhkan method tersebut, yaitu parameter yang diberikan pada

method yang akan digunakan sehingga dapat berjalan sesuai dengan yang diperlukan.

Untuk memberi pemahanan yang lebih jelas tentang komunikasi antar objek-objek dapat

kita lihat pada contoh 2.1.

Contoh 2.1 : anotherObject.aMethod(parameter1);

Misalkan objek Budi meminta objek Iwan untk membawa mobil Budi, maka

Budi akan memanggil objek Iwan dengan perintah Iwan bawaMobil serta memberikan

kuncil mobilnya. Dalam pemrograman berorientasi objek, perlakuan ini dapat dilakukan

dengan cara,

iwan.bawaMobil ( kunciMobilBudi );

Ini menunjukkan bahwa objek yang dituju oleh objek Budi adalah objek Iwan

dengan behavior (method) yang dibutuhkan bawaMobil yang dalam hal ini objek iwan

27


mempunyai kemampuan membawa mobil, sedangkan parameter yang dibutuhkan oleh

objek Iwan dalam membawa mobil adalah kunci mobil budi. Pernyataan Objek Iwan

mempunyai kemampuan membawa mobil menunjukkan bahwa di dalam class yang

meng-instansiasi objek iwan mengandung method bawaMobil. Dengan kata lain, di

dalam class yang meng-instansiasi objek iwan terdapat method bawaMobil.

Bila sebuah objek ingin memanggil method miliknya sendiri, maka informasi

pertama adalah dirinya sendiri. Untuk menunjuk diri sendiri dalam Java digunakan kata

kunci this. Maka contoh 2.1 akan menjadi seperti berikut :

this.aMethod(parameter1);

Andaikan bahwa objek Budi ingin membawa mobil miliknya sendiri, maka Budi

hanya memanggil dirinya sendiri, yaitu saya bawa mobil dengan kunci yang saya miliki.

Dalam pemrograman berorientasi objek, perlakuan ini dapat ditulis dalam bentuk;

this.bawaMobil(kunciMobilBudi);

Karena JVM java akan menginterfretasikan objek yang dituju adalah objek

dirinya sendiri saat kita hanya memanggil method maka informasi pertama pada

penulisan this.aMethod(parameter1); dapat kita dihilangkan sehingga menjadi:

aMethod(parameter1);

Dengan cara yang sama bahwa penulisan bawaMobil(kunciMobilBudi);

menunjukkan bahwa yang membawa mobil adalah objek Budi sendiri, karena bila

informasi pertama tidak ada (tanpa menggunakan menggunakan kata kuci this), kompiler

akan secara otomatis menunjuk ke objek itu sendiri.

Dari penjelasan di atas dapat kita simpulkan bahwa penggunaan pesan

mempunyai dua keuntungaan , yaitu:

1. semua kebutuhan interaksi antar objek dapat dilakukan, maksudnya bahwa kita hanya

perlu mengetahui objek apa yang akan kita gunakan serta apa kemampuann objek

28


tersebut (method yang dimiliki oleh objek yang kita gunakan)

2. objek-objek yang saling berinteraksi tidak harus berada dalam satu proses atau

bahkan dalam satu komputer, maksudnya kita dapat menggunakan objek-objek yang

berada dalam direktori atau komputer yang berbeda asalkan kita mengetahui direktori

atau alamat komputer objek tersebut berada.

Jadi penggunaan pesan (message) akan mempermudah kita di dalam mengontrol

perlakuan setiap objek atau dengan penggunaan pesan akan memberikan keleluasaan di

dalam menggunakan behavior (method) yang dimiliki oleh objek-objek yang kita

butuhkan.

2.5 Kelas (Class)

Kita telah jelaskan di atas bahwa objek merupakan instansiasi dari suatu class.

Kelas adalah semacam cetakan, atau template, untuk membuat objek. Misalkan sebuah

rancangan rumah yang digunakan untuk membangun ratusan rumah. Rumah yang

dibangun tersebut adalah objek dari kelas rancangan rumah. Hal ini dapat dilakukan

karena semua objek rumah yang dibangun memiliki karakteristik yang sama, sehingga

dapat dibuatkan semacam blueprint-nya. Tetapi objek-objek yang dibangun tetap akan

memiliki bentuk fisik tertentu sendiri-sendiri, seperti variabel dalam sebuah program,

atau pintu sebuah objek rumah. Dengan penjelasan ini, kelas dapat kita definisikan

kembali menjadi sebuah blueprint, atau prototipe, yang mendefinisikan variabel dan

method yang sama untuk semua objek sejenis.

Sebagai contoh, misalkan kita ingin membuat kelas Rumah, maka kita harus

membuat sebuah kelas yang mendefinisikan semua variabel yang dimiliki objek dari

kelas tersebut. Selain itu, kelas tersebut juga harus mendeklarasikan method-method yang

dimiliki objek dari kelas dan juga membuat implementasi dari method tersebut. Dengan

adanya kelas ini, kita dapat membuat sebanyak apapun objek-objek rumah yang sejenis,

yaitu jenis yang didefinisikan oleh kelas Rumah. Setiap objek Rumah diciptakan, sistem

akan mengalokasikan sejumlah memori untuk objek tersebut dan variabel-variabelnya.

Dengan begitu setiap objek akan memiliki salinan masing-masing untuk setiap variabel

instans.

Setelah mengenal konsep kelas, saatnya kita akan membahas konsep variabel

29


kelas. Variabel kelas sebenarnya sama dengan variabel instans. Bedanya adalah, setiap

objek berbagi satu dan hanya satu variabel kelas, tapi masing-masing memiliki salinan

dari variabel instans. Misalkan kelas Rumah yang kita buat hanya akan mendukung 2

lantai, dan setiap objek Rumah terdiri atas 2 lantai. Maka informasi ini cukup disimpan

satu kali, karena nilainya tidak berbeda untuk semua objek. Lebih jauh, bila ada satu

objek yang mengubah nilai dari variabel kelas, maka semua objek sejenis lainnya akan

mengikuti perubahan itu. Di samping variabel, terdapat juga method kelas. Method jenis

ini dapat langsung dipanggil melalui kelas dan bukan dari instans kelas tersebut.

30


Soal Latihan Bab 2. 1. Setiap Objek selalu memiliki state dan behavior. Jelaskan apa yang dimaksud state dan

behavior dan berikan masing-masing contohnya.

2. Apa yang dimaksud dengan variable instans dan method instans.

3. Berikan contoh interaksi antar objek yang ada pada lingkungan sekitar Anda dan

jelaskan maksudnya.

4. Dari soal no 3, berikan contoh interaksi antar objek dalam pemrograman berorientasi

objek.

5. Apa yang dimaksud dengan message.

6. Jelaskan informasi-informasi apa saja yang dibutuhkan oleh suatu objek saat objek

tersebut hendak berkomunikasi dengan objek lain.

7. Sebutkan keuntungan dari penggunaan message.

8. Berikan contoh penggunaan Inheritance dalam kehidupan Saudara.

9. Jelaskan manfaat dari penggunaan Inheritance.

10. Berikan contoh penggunaan Interface dalam kehidupan Saudara.

31


Bab 3 Object, Class, Message dan Method

Pada bab 2, kita telah memperkenalkan secara sederhana konsep dari object, class,

message dan method. Object dan message itu berhubungan dengan konsep class. Pada

pemrograman berorientasi-objek, suatu class merupakan suatu tempelate dari struktur

suatu objek dan merupakan sumber pembentukan objek-objek. Pada bab ini, kita akan

membahas lebih dalam mengenai konsep dari object, messsage, method dan class serta

bagaimana konsep ini digunakan di dalam suatu model komputer.

3.1 Objects dan Class

Pada bab 2 kita telah memperkanalkan bahwa Jasman dan Jaselline sebagai

pembeli di took buku. Tentunya Jasman dan Jeselline akan memiliki beberapa informasi

yang sama sebagai seorang pembeli. Sebagai contoh, keduanya memiliki nama, alamat,

dan anggaran yang dimilikinya. Informasi ini dikenal dengan istilah atribut dari suatu

objek (object attributes).

Nilai dari atribut suatu objek yang akan diberikan tentunya merupakan suatu nilai

atribut (attribute values) yang bebas, maksudnya nilainya dapat berbeda antara satu objek

dengan objek lainnya. Misalkan, objek Jasman memiliki nilai atribut anggaran sama

dengan Rp.100.000,- sedangkan Jaselline memiliki nilai atribut anggaran sama dengan

Rp.200.000,-. Contoh lainnya adalah nilai atribut nama untuk objek Jasman adalah

Jasman sedangkan untuk objek Jaselline adalah Jaselline. Nilai atribut dari suatu objek

bisa saja memiliki nilai atribut yang sama. Misalkan objek Jasman memiliki nilai atribut

alamat Bandung. Jaselline tinggal pada rumah yang sama dengan Jasman, maka nilai

atribut alamat untuk objek Jaselline adalah Bandung.

Sebagai seorang pembeli, tentunya Jasman dan Jaselline bisa membeli buku.

Ketika mereka hendak membeli buku maka mereka akan mengeksekusi suatu method,

misalkan method-nya adalah purchase(). Saat mereka menggunakan method

purchase() maka sekumpulan operasi akan dijalankan sehingga memperbolehkan

mereka untuk meminta seorang penjual melayani permintaan mereka dalam mebeli buku.

32


Secara struktural, objek Jasman dan Jaselline dapat direpresentasikan sebagai

berikut :

Jasman sebagai suatu object atributnya : name = “Jasman” address = “Bandung” budget = “100.000” methods : purchase( ) { mengirimkan suatu permintaan pembelian pada seorang penjual} getBudget( ) {return anggaran} Jaselline sebagai suatu object atributnya : name = “Jaselline” address = “Bandung” budget = “200.000” methods : purchase( ) { mengirimkan suatu permintaan pembelian pada seorang penjual} getBudget( ) {return anggaran}

name, address, dan budget adalah atribut sedangkan purchase()

dan getBudget() merupakan dua method yang dimiliki oleh kedua objek tersebut.

Perlu dicatat bahwa kedua objek memiliki pendefisian atribut dan method yang sama.

Pada kehidupan nyata, semua pembeli memiliki atribut yang sama, yaitu atribut name,

address, dan budget. Pembeli juga memiliki hak yang sama, yaitu memiliki

method purchase() dan getBudget(). Untuk membuat objek-objek tersebut,

maka kita gunakan pendefinisian yang umum, yang dikenal dengan istilah class .

Class adalah suatu pendefinisian template untuk penstrukturan dan penciptaan objek-

objek yang memiliki atribut dan method-method yang sama. Jasman dan Jaselline, akan

menjadi pelanggan pada toko buku tersebut, dengan demikian kita dapat

mendefinisikannya dengan suatu class dengan nama class Customer sebagai berikut :

Class Customer attributes : name address budget methods : purchase( ) { mengirimkan suatu permintaan pembelian pada seorang penjual} getBudget( ) {return anggaran}

33


Salah satu yang membedakan antara objek dan class adalah cara pandang

mengenai atribut dan method yang dimiliki oleh objek dan class. Suatu class adalah suatu

pendefinisi tentang objek-objek; atribut dan method yang dimiliki oleh class hanya

sebagai deklarasi yang tidak mengandung nilai. Dengan demikian, objek diciptakan dari

instansiasi dari suatu class. Setiap objek akan memiliki nilai atribut dan method, yang

masing-masing nilai atribut akan mengambarkan secara khusus keberadaan dari suatu

objek.

Sekarang kita perhatikan disisi penjual. Penjual juga memiliki atribut dan method.

Anton dan Budi merupakan penjual yang melayani di toko buku. Mereka biasanya

memiliki kemampuan untuk membuat faktur pembelian yang dibeli oleh pembeli. Ketika

mereka hendak membuat faktur pembelian maka mereka akan mengeksekusi suatu

method, misalkan method-nya adalah makeBilling(). Saat mereka menggunakan

method makeBilling() maka sekumpulan operasi akan dijalankan sehingga

memperbolehkan mereka untuk membuat faktur pembelian yang diminta. Secara

struktural, objek Anton dan Budi dapat direpresentasikan sebagai berikut :

Anton sebagai suatu object atributnya : name = “Anton” methods : makeBilling( ) {

check jumlah stock cukup atau tidak check CD source code ada atau tidak if ok then{ kasir printBilling (jumlah, harga, tglBeli) return ok

} else{ return not ok

} }

Budi sebagai suatu object atributnya : name = “Budi” methods : makeBilling( ) {

check jumlah stock cukup atau tidak check CD source code ada atau tidak if ok

34


then{ kasir printBilling (jumlah, harga, tglBeli) return ok


} }

Pada objek Anton dan Budi kita lihat bahwa mereka memiliki atribut dan method

yang sama. Dengan konsep yang sama seperti pada pembeli, pendefinisian objek ini

dapat kita deskripsikan pada suatu class yang disebut class SalesPerson , yang

direprensentasikan sebagai berikut :

Class SalesPerson attributes : name methods : makeBilling( ) {

check jumlah stock cukup atau tidak check CD source code ada atau tidak if ok then{ kasir printBilling (jumlah, harga, tglBeli) return ok


} }

Perlu diperhatikan bahwa pendefinisian class SalesPerson berbeda dengan

class Customer , karena Customer (pembeli) dan SalesPerson (penjual) memiliki

perlakuan yang berbeda, yaitu pembeli meminta pembuatan faktur transaksi sedangkan

penjual membuat faktur transaksi tersebut.

3.2 Message dan Method

Untuk memberikan pemahaman yang lebih jelas didalam komunikasi antar objek

kita akan menerapkan contoh kasus antara pembeli dan penjual yang telah dibahas pada

subbab di atas. Seperti yang telah dijelaskan pada sub bab 2.4 suatu objek berkomunikasi

dengan objek lain melalui suatu pengiriman message (pesan).

35


Pada contoh penjual dan pembeli sebelumnya kita melihat bahwa Jasman

mengirimkan message kepada Anton untuk membuat faktur pembelian buku. Message

yang dikirimkan oleh Jasman kepada Anton adalah dengan memanggil method

purchase() yang ada pada diri Jasman. Saat Jasman meminta method

purchase(), maka Anton yang saat itu sebagai penjual yang diminta oleh Jasman

akan memanggil method makeBilling() yang ada pada diri Anton. Sehingga

structural komunikasi antar objek akan direpresentasikan sebagai berikut (yang ditandai

dengan cetak tebal)

Jasman sebagai suatu object atributnya : name = “Jasman” address = “Bandung” budget = “100.000” methods : purchase( ) {

Anton.makeBilling(“OOP-Java”, 5, “Jasman”, “10 Agust 2010”) }

getBudget( ) {return anggaran}

Message Anton.makeBilling(buku, jumlah, namaPembeli,

tglBeli) diinterpretasikan sebagai berikut :

1. Anton adalah penerima message

2. makeBilling adalah suatu method yang dipanggil pada objek Anton

3. “OOP-Java”, 5, “Jasman”, “10 Agust 2010” merupakan

argumen dari message.

3.3 Method

Suatu message dikatakan suatu message yang valid jika penerima message

memiliki method yang diminta oleh pengirim message dan dengan argument yang sesuai

dengan yang dibutuhkan oleh penerima message. Message yang dapat dieksekusi oleh

objek penerima message adalah hanya message yang valid. Message makeBilling

() dikatakan valid karena Anton memiliki method tersebut dan Jasman yang meminta

Anton untuk mengeksekusi method makeBilling() tersebut juga memberikan

argumen yang sesuai dengan yang dibutuhkan oleh method makeBilling() .

36


Method makeBilling() yang dimiliki oleh Anton memiliki sejumlah operasi

seperti yang dinyatakan pada huruf tebal berikut ini :

Anton sebagai suatu object atributnya : name = “Anton” methods : makeBilling( buku, jumlah, namaPembeli, tglBeli ) {

check jumlah stock cukup atau tidak check CD source code ada atau tidak yang dimiliki oleh buku tersebut if ok then{ kasir printBilling (jumlah, harga, tglBeli) return ok


} }

Pada deskripsi di atas, suatu message dikirimkan dari Anton ke objek petugas

gudang untuk menanyakan apakah stok dari buku yang diminta masih ada dan CD source

code yang bersesuain dengan buku yang dibeli juga masih ada. Jika kedua kondisi ini

dipenuhi maka Anton akan meminta objek kasir untuk melakukan printBilling() .

Bagaimana Anton melakukan pekerjaannya sampai dihasilkan faktur pembelian,

hanya diketahui oleh Anton sendiri. Jasman maupun Jaselline dan pembeli yang lain

tidak pernah tahu bagaimana Anton melakukan proses pembuatan faktur pembelian.

Sebagai contoh, saat Anton meminta petugas gudang untuk mencek apakah stok buku

cukup atau tidak, Anton bisa saja menelepon petugas gudang untuk menanyakannya dan

bisa juga Anton langsung ke gudang dan menanyakan langsung ke penjaga gudang atau

bisa juga Anton melihat daftar stok buku yang tersedia saat itu yang ada di gudang. Apa

yang diketahui oleh Jasman dari Anton adalah bahwa Anton mempunyai kemampuan

untuk membuat faktur pembayaran, karena message yang dikirimkan kepada Anton dapat

dilayani oleh Anton.

Pada pemrograman berorientasi objek, komunikasi antara Jasman dan Anton

mengikuti prinsip penyembunyian informasi (information hiding)- bagaimana Anton

melayani permintaan Jasman disembunyikan dari Jasman. Dalam hal ini, Anton secara

bebas melakukan operasi atau kegiatan apapun yang diperlukan untuk memenuhi

37


permintaan Jasman, apakah melalui telepon, langsung ke gudang atau melihat daftar stok

buku.

3.4 Penciptaan Objek

Pada pemrograman berorientasi objek, objek diciptakan dari suatu class.

Instansiasi dari objek-objek Customer diciptakan dari suatu class Customer dan objek-

objek SalesPerson diciptakan dari class SalesPerson .

Instansiasi dari objek yang diciptakan merupakan individu-individu yang

berhubungan dengan state (atribut dan method) yang dimilikinya. Untuk

mengilustrasikan hal tersebut, kita perhatikan contoh Counter. Suatu Counter adalah

suatu perangkat yang memelihara nilai dari suatu kejadian yang telah terjadi. Misalkan

Counter tersebut memiliki dua buah button; satu button initialize yang berfungsi untuk

menginisialisasi nilai ke 0 dan button yang lain adalah button add yang melakukan proses

penambahan satu-satu angka setiap kejadian. Seperti yang digambarkan pada gambar 3.1.

Gambar 3.1 Sebuah objek Counter

Secara structural, objek counter pertama dapat direpresentasikan sebagai berikut :

First Counter object attributes: number = 10 methods : add( ) { number = number + 1 } initialize( ) { number = 0 } getNumber( ) { return number }

Gambar 3.2 menunjukkan dua buah objek Counter dengan nilai identifier number

pertama sama dengan 2 dn nilai identifier number yang kedua adalah 7.

38


Gambar 3.2 Dua buah objek Counter

Secara structural, dua buah objek counter dapat direpresentasikan sebagai berikut

:

Second Counter object attributes: number = 2 methods : add( ) { number = number + 1 } initialize( ) { number = 0 } getNumber( ) { return number }

Third Counter object attributes: number = 7 methods : add( ) { number = number + 1 } initialize( ) { number = 0 } getNumber( ) { return number }

Jika kita lihat ketiga objek Counter tersebut, masing-masing memiliki

pendefinisian atribut dan method yang sama, maka kita dapat buatkan template untuk

menciptakan ke tiga objek Counter tersebut seperti yang ditunjukkan pada Gambar 3.3.

Gambar 3.3 Template Pembuatan Objek Counter

Dari gambar 3.3 kita dapat mendefinisikan pembuatan objek counter kedalam

suatu class Counter, seperti yang dinyatakan berikut ini :

Class Counter

Atribut number yang nilainya tergantung pada objek yang diciptakan

39


attributes: number methods : add( ) { number = number + 1 } initialize( ) { number = 0 } getNumber( ) { return number }

Class Counter memiliki :

1. Atribut, number

2. Method add( ) yang memerintahkan nilai counter bertambah satu dari nilai

number sebelumnya

3. Method initialize() yang memerintahkan nilai counter untuk reset nilai

number menjadi 0

4. getNumber() yang mengembalikan nilai number saat objeknya dipanggil

Misalkan suatu objek diciptakan dari suatu class Counter . Walaupun objek

counter yang baru memiliki pendefinisian atribut dan method yang sama dengan ke tiga

objek sebelumnya, nilai dari atribut objek yang baru bisa saja tidak sama dengan counter

yang lain. Ini menyatakan bahwa state dari objek counter bias berbeda dengan objek yang

lain.

Misalkan kita mencipatakan suatu objek counter yang ke empat dari template

class Counter yang kita miliki dengan nilai atribut number kita berikan adalah 26,

maka objek counter ke empat dapat dinyatakan sebagai berikut :

Fourth Counter object attributes: number = 26 methods : add( ) { number = number + 1 } initialize( ) { number = 0 } getNumber( ) { return number }

Dengan representasi objek seperti yang dinyatakan pada Gambar 3.4.

40


Gambar 3.4 Sebuah objek Counter dengan atribut number 26

Perlu dicatat bahwa nilai atrubut dari ke empat objek Counter di atas memiliki

nilai yang berbeda antara objek counter yang satu dengan objek counter yang lainnya.

26

41


Soal Latihan Bab 3. 1. Jelaskan perbedaan antara Objek dan Class. 2. Buatlah skenario dari proses peminjaman CD/DVD pada rental CD/DVD antara

peminjam dengan operator rental. Buatlah class-class yang dibutuhkan untuk transaksi peminjaman CD/DVD tersebut, kemudian tentukan methodnya masing-masing dan komunikasi antar objek yang terjadi.

3. Misalkan suatu class Buku yang didefinisikan sebagai berikut :

Class Buku attributes: title

authors pages price methods: getTitle( ) {return title} getAuthors {return authors} getPages( ) {return pages} getPrice( ) {return price}

Buatlah 4 buah objek dari instansiasi dari class Buku tersebut.

4. Jelaskan bagaimana cara menciptakan suatu class dari kumpulan objek-objek yang ada? Berikan contohnya.

5. Jelaskan apa yang dimaksud dengan message yang valid? 6. Apakah setiap komunikasi antar objek selalu dapat dilakukan? Jelaskan alasan

Saudara serta berikan contohnya.

42


Bab 4 Class dan Object pada Java

Unsur dasar pemrograman berorientasi-objek pada Java adalah class. Class

mendefinisikan bentuk dan sifat suatu objek. Konsep yang ingin direpresentasikan dalam

program Java dienkapsulasi dalam sebuah class. Biasanya class Java akan berisi variabel

dan method instans. Program Java yang lengkap biasanya terdiri dari sejumlah class Java

dari file sumber yang berbeda.

Class adalah pola atau tempelate untuk sebuah objek. Class mendefinisikan

struktur objek dan antarmuka fungsionalnya, yang dikenal sebagai method. Saat program

Java dijalankan, sistem menggunakan definisi class untuk menciptakan instans class

tersebut, yang menjadi objek sebenarnya. Bentuk umum definisi class ditunjukkan

berikut ini :

class Classname extends superclassname{

type instance-variabel1;

type instance-variabel2;

type methodName1(parameter list){

method-body

}

type methodName2(parameter list){

method-body

}

}

Classname dan superclassname dapat berupa identifier apa saja yang berlaku. Kata

kunci extends digunakan untuk menunjukkan bahwa classname adalah subclass dari

superclassname.

Esensi pendefinisian suatu class adalah sangat sederhana. Ada dua hal yang

dimasukkan dalam pendefinisian suatu class yaitu :

1. Field, variabel yang menyimpan item-item data yang biasanya berbeda antara

satu objek dengan objek yang lain, dapat juga merujuk sebagai bilangan dari

class. Istilah variabel, field, dan bilangan dari class semuanya sama.

43


2. Method, mendefinisikan operasi yang dapat dilakukan pada class, sehingga dapat

ditentukan apa yang dapat dilakukan objek suatu class.

4.1 Variabel dalam suatu Class

Objek adalah suatu instansiasi dari suatu class. Saat menciptakan suatu objek,

objek tersebut akan mengandung variabel-variabel yang dimiliki oleh class yang

didefinisikan. Dengan demikian, variabel dalam suatu class tidak selalu sama dengan

variabel yang dimiliki oleh objeknya. Misalkan seseorang tertentu merupakan objek dari

class Manusia yang memiliki variabel nama, alamat, umur. Variabel-variabel ini disebut

variabel instans karena nama, alamat, dan umur setiap objek pasti berbeda dan nilainya

ada pada objek yang kita tentukan. Sedangkan variabel yang terbentuk sebelum adanya

suatu objek disebut variabel class. Variabel class ini dirujuk sebagai static field yang

diimplementasikan dengan kata kunci static saat di deklarasikan dalam suatu class.

Contoh 4.1 :

Class Bola

public class Bola globe { 3.14 xCenter

// variabel class yCenter static double PI = 3.14; zCenter radius // variabel instans double xCenter; doubel yCenter; double zCenter; double radius;

} bolaBasket xCenter yCenter zCenter radius

Pada ilustrasi contoh 4.1 di atas menunjukkan bahwa class Bola mengandung satu

variabel class, yaitu PI, dan empat variabel instans, yaitu xCenter, yCenter, zCenter,

dan radius. Objek globe dan bolaBasket akan memiliki nilai xCenter, yCenter,

zCenter, dan radius masing-masing tetapi akan memiliki nilai PI yang sama yang

diperoleh dari copy-an dari variabel classnya.

44


Misalkan kita hendak membuat class Manusia yang selalu memiliki kemampuan

berbahasa Indonesia dengan kata lain bahwa setiap objek manusia mempunyai

kemampuan bahasa Indonesia, tetapi memiliki nama, alamat dan umur yang berbeda.

Maka di dalam pembuatan class manusia kita akan memiliki variabel class yaitu bahasa,

dan variabel instans nama, alamat dan umur. Pendefinisian class Manusia dari variabel

yang dimiliki oleh class Manusia dapat dibuat seperti yang ditunjukkan pada contoh 4.2.

Contoh 4.2

Public class Manusia { // variabel class public static String bahasa = “Indonesia”;

// variabel instant public String nama;

public String alamat; public int umur; }

Berdasarkan jenis variabel yang digunakan pada suatu class maka penggunaan

dan pemanggilan variabel dibedakan atas dua cara. Setiap variabel class dapat kita

gunakan atau panggil dengan cara memanggil nama class yang diikuti dengan nama

variabelnya. Sedangkan penggunaan dan pemanggilan variabel instans dilakukan dengan

cara membentuk objek dari kelas yang ada, kemudian dari objek yang terbentuk kita

dapat menganggil variabel yang kita maksudkan. Dengan kata lain, variabel class dapat

kita panggil dan gunakan tanpa harus membentuk objeknya, sedangkan variabel instans

hanya dapat kita gunakan atau dipanggil jika kita telah membentuk objek dari classnya.

Misalkan dalam contoh 4.1 class Bola di atas, kita dapat menggunakan variabel

class PI dengan cara Bola.PI. Sedangkan untuk menggunakan variabel instans seperti

xCenter, yCenter, zCenter dengan cara membentuk objek Bola, seperti yang

ditunjukkan pada contoh 4.3.

Contoh 4.3 :

public globe = new Bola( ); // bentuk objek globe dari class Bola

globe.xCenter = 7.9; //gunakan variabel instan dgn men-set nilai xCenter dengan 7.9

45


globe.yCenter = 4.3;

globe.zCenter = 3.5;

globe.radius = 7.0;

4.2 Method dalam suatu Class

Method mendefinisikan aksi apa yang dapat dilakukan oleh suatu class. Ada dua

jenis method yang dapat dilakukan pada suatu class, yaitu method instans dan method

class. Method class dapat dieksekusi saat sebelum terbentuk objek dari suatu class,

sedangkan method instans hanya dapat dieksekusi pada suatu objek tertentu, sehingga

jika tidak ada objek maka method instans tidak dapat dieksekusi. Method class

dideklasikan dengan menggunakan kata kunci static.

Method class dapat dieksekusi saat belum terdapat objek class, untuk itu method

class tidak boleh mengandung atau merujuk kepada variabel instan. Karena compiler Java

akan memberikan kesalahan saat suatu method class merujuk pada suatu variabel instan

maka pada suatu method class jangan merujuk variabel instan. Misalkan method main( ),

yang menjalankan aplikasi Java, harus selalu dideklarasikan sebagai static yang

menunjukkan bahwa method tersebut dapat dieksekusi sebelum terbentuk suatu objek

tertentu. Jadi jika kita membutuhkan suatu method yang dapat dieksekusi sebelum

terbentuknya suatu objek, maka kita mendefinisikan method tersebut sebagai method

class. Seperti yang ditunjukkan pada contoh 4.4.

Contoh 4.4.

public class NamaClass{ public static typeData methodClass(paramter){// deklarasi method class

. // tidak diperbolehkan

. // pendeklarasian var. . // instant tetapi var. class } public typeData methodInstand(paramter){// deklarasi method instant

. // tidak diperbolehkan

. // pendeklarasian var. . // instant tetapi var. class } }

46


4.3 Pengaksesan Variabel dan Method

Kita sering ingin mengakses variabel dan method yang didefinisikan pada suatu

class, yang berada di luar class-nya sendiri. Seperti yang dijelaskan di atas dalam

mengakses variabel dan method static dari suatu class dapat dilakukan dengan

menggunakan nama class yang diikuti dengan nama variabel atau method class yang

diinginkan.

Misalkan jika kita ingin mengambil akar dari π dengan menggakses method class

sqrt dan variabel class PI yang didefinisikan dalam class Math, maka dapat dilakukan

dengan cara berikut :

double akarPI = Math.sqrt(Math.PI);

Variabel dan method instan hanya dapat di akses dengan menggunakan objek

yang merujuknya. Misalkan untuk mengakses method volume( ) yang ada dalam class

Bola, oleh suatu bolaBasket objek dari class Bola, maka dilakukan dengan cara,

bolaBasket = new Bola( ); // bolaBasket objek dari class Bola

bolaBasket.volume( ); // menggunakan method instan volume( )

4.4 Pendefinisian Class

Untuk mendefinisikan suatu class dilakukan dengan cara pemberian kata kunci

class yang diikuti oleh nama classnya. Secara konvensional nama class dalam Java

diawali dengan huruf besar. Source code suatu class disimpan dengan nama yang sama

dengan nama classnya dan diikuti dengan ekstensi .java. Disamping pendeklarasian

variabel class, kita sering menemukan data yang bersifat konstanta yang tidak pernah

diubah. Pendeklarasian variabel konstanta pada pemrograman Java dilakukan dengan

cara menggunakan kata kunci final pada variabel yang kita maksud, seperti yang

ditunjukkan pada contoh 4.5 di bawah ini.

Contoh 4.5

/* * Nama File : MVStatic.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1

47


*/

1 public class MVStatic{ 2 static final double VS = 1.23; 3 4 double xPanjang = 15.9; 5 6 public static void getValue(){ 7 System.out.println("Ini dalam variabel static method : " + VS); 8 } 9 10 public void getAddress(){ 11 System.out.println("Ini method instan "); 12 } 13 }

Pada source code contoh 4.5 nilai VS bersifat final, sehingga setiap objek yang

merupakan instansiasi dari class ini tidak akan pernah dapat merubah nilai VS.

Keuntungan parameter sebagai final adalah :

1. mencegah pengubahan suatu nilai yang tidak diharapkan untuk berubah.

2. dapat memampukan compiler untuk membuat coding lebih efisien.

4.5 Pendefinisian Method

Method adalah suatu block code yang memiliki nama dan properti yang dapat di

reusable. Suatu method dieksekusi dengan memanggil nama methodnya, dan suatu

method dapat mengembalikan suatu nilai atau tidak mengembalikan nilai. Struktur dasar

dari suatu method adalah sebagai berikut :

return_type methodName ( arg1, arg2, . . . , argn ){

// executable code

}

Suatu method yang tidak mengembalikan nilai di deklarasikan dengan kata kunci

void, sedangkan untuk method yang mengembalikan nilai akan dideklarasikan sesuai

dengan tipe-nya. Pada contoh 4.6 merupakan contoh pendeklarasian method yang

mengembalikan nilai yaitu berupa tipe double yang diperoleh dari variabel volum

sedangkan contoh 4.7 merupakan contoh pendeklarasian method yang tidak

mengembalikan nilai.

48


Contoh 4.6.

public static double hitungVolum(double _r){//tipe data yang dikembalikan adalah double

double volum; // volum memiliki tipe data double

volum = 4/3*(Math.PI)*(_r*_r*_r);

return volum; //gunakan kata kunci return diikuti nama varibel volum

}

Contoh 4.7.

public void printVolum(double _r){ //gunakan kata kunci void tanpa mengembalikan nilai

System.out.println(“Rumus Hitung Volume Bola adalah 4/3*(Math.PI)*(_r*_r*_r) ”);

}

4.5.1 Pengembalian nilai suatu Method

Untuk mengembalikan nilai dari suatu method saat method tersebut dieksekusi

digunakan dengan pendeklarasian kata kunci return, misalnya

return return_value;

ini menunjukkan bahwa nilai yang akan dikembalikan adalah nilai yang dimiliki oleh

variabel return_value. Untuk memberikan pemahaman yang jelas tentang pengembalian

nilai suatu method dapat kita perhatikan seperti yang diberikan pada contoh 4.8.

Contoh 4.8 :

/* * Nama File : VolumeBola.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.lang.Math; 2 3 public class VolumeBola{

4 5 public static void main(String []args){

6 double htVolum; 7 htVolum = hitungVolum(5.0); 8 System.out.println("Volume Bola adalah :" + htVolum); 9 } 10 // Pengembalian nilai suatu method 11 public static double hitungVolum(double _r){

12 double volum;

13 14 volum = 4/3*(Math.PI)*(_r*_r*_r);

49


15 return volum;

16 } 17 }

Pada contoh 4.8 menunjukkan bahwa pada baris 7 meminta method hitung volume untuk

menghitung volume bola jika diberikan dengan nilai jari-jari sama dengan 5. Untuk

menghitung volume tersebut memanggil method hitungVolum yang terdapat pada baris

11 dan hasil perhitungan akan mengembalikan nilai yang bertipe double. Nilai volum

didapatkan dari perhitungan 4/3*(Math.PI)*(_r*_r*_r) seperti pada baris 14 kemudian nilai

informasinya ditampilkan sesuai dengan hasil eksekusi pada baris 8. Adapun hasil

eksekusi program yang diperoleh dari source code contoh 4.7 seperti yang ditunjukkan

pada gambar 4.1

Gambar 4.1 Hasil eksekusi contoh 4.8

4.5.2 Perbedaan antara Parameter dengan Argument

Parameter list adalah suatu tipe tertentu yang nilainya dapat diberikan sebagai

argumen kepada suatu method. Parameter merupakan suatu nama yang muncul dalam

parameter list dalam pendefinisian suatu method. Suatu parameter mendefinisikan tipe

nilai yang dapat dikirimkan ke method, dan nama yang digunakan merujuk pada code

yang digunakan pada method. Sedangkan argument adalah suatu nilai yang dikirimkan ke

suatu method saat dieksekusi. Jadi parameter adalah variabel yang mengidentifikasi nilai

pada suatu method sedangkan argumen adalah nilai yang dieberikan pada suatu method.

Volume bola dgn r = 5, bertipe double

50


Contoh 4.9

public double calculate(double x, double y){ double z; z = x*y; return z; }

oStatic.calculate(1.5,4)

Pada contoh 4.9 di atas method calculate( ) memiliki dua parameter, yaitu x dan y yang

tipenya double yang digunakan untuk merujuk ke argumet 1.5 dan 4.

Method calculate ( ) mendeklarasikan variabel z, yang hanya ada saat body method.

Variabel ini diciptakan saat method calculate dieksekusi dan akan di musnahkan

(destroyed) saat pengeksekusian method selesai. Semua variabel yang di deklarasikan

dalam body method disebut variabel local dan hanya ada saat method tersebut dieksekusi.

4.5.3 Passing nilai argument

Pada Java, semua nilai argument ditransfer ke suatu method dengan menggunakan

suatu method yang disebut mekanisme pass-by-value. Seperti yang ditunjukkan pada

gambar 4.2.

public static void main(String[] args){ i

int i = 26; 26

int j = obj.tambah(i); copy dari i

26

} rujuk nilai k

dari copy-an i

int tambah (int k){

++ k;

return k;

}

Gambar 4.2 Passing nilai Argument

Pada gambar 4.2 di atas menunjukkan bahwa nilai argument yang dikirimkan ke suatu

method terlebih dahulu melakukan proses copy, dan nilai copy-annya yang dikirimkan ke

x dan y merupakan parameter

1.5 argument untuk x, dan 4 argument untuk y

51


methodnya bukan nilai originalnya. Jadi saat method di atas dieksekusi nilai j akan

memiliki nilai 27, sedangkan nilai i akan tetap 26.

4.6 Variabel this

Setiap method instan mempunyai suatu variabel yang dinamai dengan this, yakni

yang merujuk pada objek saat itu dimana method-nya dipanggil. Seperti yang kita bahas

pada bab 2 bahwa kata kunci this digunakan secara implisit oleh compiler saat method

merujuk ke suatu method class dirinya sendiri. Kata kunci this digunakan juga sebagai

variabel pada suatu class. Contoh, saat method volume ( ) merujuk ke suatu variabel

instan radius, compiler akan memasukkan this objek yang dirujuk, yaitu this.radius.

Sehingga method volume akan memiliki statement sebagai berikut :

return 4.0/3.0*PI*this.radius*this.radius*this.radius;

untuk memberi gambaran yang jelas tentang penggunaan variabel this, mari kita lihat

contoh 4.10 berikut.

Contoh 4.10

/* * Nama File : MVStatic.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MVStatic{ 2 static final double VS = 1.23;

3

4 double xPanjang = 15.9; 5 double radius; 6 static final double PI = 3.14; 7 8

9 public static void getValue(){ 10 System.out.println("Ini dalam variabel static method : " + VS); 11 } 12

13 public void getAddress(){ 14 System.out.println("Ini method instan "); 15 } 16

52


17 public double calculate(double x, double y){ 18 double z; 19 20 z = x*y; 21 return z; 22 } 23 24 public double volume(){

25 return 4.0/3.0*PI*radius*radius*radius; 26 } 27

28 public void setXPanjang(double x){ 29 this.xPanjang = x; // sama dengan - > xPanjang = x; 30 } 31 32 public void changeRadius(double myRadius){ 33 this.radius = myRadius; 34 } 35 36 }

Nama variabel yang dideklarasikan pada suatu method adalah variabel lokal. Jika kita

ingin mengubah nilai variabel suatu objek dapat dilakukan dengan menambahkan kata

kunci this kemudian menggunakan variabel instannya, seperti yang ditunjukkan pada

bagian dibawah ini;

public void changeRadius(double myRadius){ this.radius = myRadius; }

Seperti yang diberikan pada contoh 4.10 bahwa pada baris 29 variabel xPanjang maka

diawali dengan kata kunci this, maka variabel xPanjang pada baris 29 bukan lagi variabel

lokal tetapi variabel global yang dimiliki oleh class MVStatic. Sama halnya dengan

variabel radius pada baris 33 juga merupakan variabel global. Untuk memperjelas

pemahaman kita tentang penggunaan kata kunci this, berikut ini kita akan mengeksekusi

cource code contoh 4.10 dengan driver contoh 4.11 berikut.

Contoh 4.11 :

/* * Nama File : AMVStatic.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

53


1 public class AMVStatic{ 2 3

4 public static void main(String[] args){ 5 System.out.println("Ini dalam Method instans"); 6 System.out.println("Nilai dari variabel class : " + MVStatic.VS); 7 MVStatic.getValue(); 8 9 MVStatic oStatic = new MVStatic(); 10 System.out.println("Nilai dari variabel instans adalah : " + oStatic.xPanjang); 11 12 13 System.out.println("Nilai hasil kali 1.5 dengan 4 : " + MVStatic.calculate(1.5,4)); 14 oStatic.setXPanjang(9.59); 15 System.out.println("Nilai dari variabel instans adalah : " + oStatic.xPanjang); 16 } 17 }

Gambar 4.3 Hasil eksekusi program contoh 4.10 dengan driver 4.11

Dengan mengimplementasikan source code contoh 4.10 dengan driver contoh 3.11 akan

memberikan penjelasan bahwa eksekusi program contoh 4.11 pada baris 6 akan

mengambil nilai variabel class yaitu 1.23 sesuai dengn nilai variabel class contoh 4.10

pada baris 2. Hasil eksekusi pada baris 14 contoh 4.11 akan memberikan nilai xPanjang

Nilai variable class dari VS

Hasil pengubahan nilai xPanjang yang tidak bersifat local tetapi

variable instan

54


yang sama dengan 9.59 pada objek oStatic yang dibentuk pada baris 9 contoh 4.11. Nilai

9.59 akan tetap ada pada objek oStatic karena argument 9.59 bukan merupakan variabel

lokal yang dicirikan dengan penambahan kata kunci this seperti yang ditunjukkan pada

contoh 4.10 pada baris 29. Adapun hasil eksekusi program contoh 4.10 dengan driver

contoh 4.11 seperti yang ditunjukkan pada gambar 4.3.

4.7 Penggunaan Block Inisialisasi

Suatu block inisialisasi adalah suatu block code antara tanda kurung yang dieksekusi

sebelum suatu objek dari suatu class diciptakan. Block inisialisasi banyak digunakan

dalam pembangkitan bilangan acak, dimana bilangan yang diciptakan akan digunakan

oleh objek dari suatu class yang kita ciptakan. Ada dua macam block inisialisasi yaitu :

1. Block inisialisasi static, yaitu suatu block yang didefinisikan dengan menggunakan

kata kunci static, yang dieksekusi saat class diload dan hanya dapat menginisialisasi

data static dari class.

2. Block inisialisasi non-static, yaitu yang dieksekusi pada setiap objek yang diciptakan

dan kemudian diinisialisasi sebagai variabel instan suatu class.

Untuk memberi pemahaman tentang kedua jenis block inisialisasi maka pada contoh 3.12

diperlihatkan contoh pembuatan block inisialisasi. Pada contoh 4.12 method yang

pertama adalah block inisialiasi non-static dan sedangkan method berikutnya adalah

inisialisasi static.

Contoh 4.12 :

/* * Nama File : TryInisialisasi.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class TryInisialisasi{ 2 static int[] values = new int [10]; 3 4 // inisialisasi block

5 static{ 6 System.out.println("Inisialisasi block ");

7 for (int i = 0; i<values.length; i++) 8 values[i] = (int)(100.0*Math.random());

55


9 } 10 11 static void listValues(){

12 13 System.out.println("===========");

14 for (int i = 0; i<values.length; i++) 15 System.out.println("Nilai ke - " + i + " adalah " + values[i]); 16 } 17 18 void listValues2(){ 19 20 System.out.println("===========");

21 for (int i = 0; i<values.length; i++) 22 System.out.println("Nilai ke - " + i + " adalah " + values[i]); 23 } 24 } 25 26 public class Inisialisasi{ 27 public static void main(String[] args){ 28 TryInisialisasi.listValues(); 29 //TryInisialisasi.listValues2(); 30 31 TryInisialisasi contohIni = new TryInisialisasi(); 32 contohIni.listValues2(); 33 } 34 35 }

Gambar 4.4 Hasil eksekusi program contoh 4.12

Block static

Block non- static

56


Pada listing code di atas diperlihatkan bahwa listValues pada basris 11 merupakan block

inisialisasi static yang ditandai dengan kata kunci static pada awal methodnya. Block

inisialisasi static ini dapat dieksekusi sebelum adanya objek instansiasi dari classnya.

Sedangkan listValues2 pada baris 18 merupakan block inisialisasi non-static dan block

inisialisasi ini hanya dapat kita bangkitkan saat objek instans suatu class terbentuk yang

dalam hal ini objek yang dibentuk adalah objek contohIni seperti yang ditunjukkan pada

baris 31. Adapun hasil yang diperoleh dari source code contoh 4.12 adalah seperti yang

ditunjukkan pada gambar 4.4 berikut.

4.8 Constructors

Saat menciptakan suatu objek dari suatu class, kita terlebih dahulu membuat

karakteristik dari objek tersebut yaitu yang disebut dengan constructor. Constructor

adalah method yang menginisialisasi objek segera setelah pembuatannya. Tujuan utama

dari constructor adalah menyediakan variabel instans yang unik bagi suatu objek yang

akan diciptakan. Suatu constructor memiliki dua karakteristik yang berbeda dengan

method class lainnya :

1. Suatu constructor tidak pernah mengembalikan suatu nilai

2. Suatu constructor selalu memiliki nama yang sama dengan nama class-nya

Suatu constructor tidak memiliki tipe keluaran bahkan tidak memiliki void sekalipun.

Untuk memberikan pemahaman yang lebih jelas tentang penggunaan constructor kita

akan membahas source code contoh 4.13 di bawah ini.

Contoh 4.13 : /* * Nama File : Bola.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class Bola{ 2 3 static final double PI = 3.14; // variabel class dengan nilai yang tetap

4 static int count = 0; // variabel class yang nilainya dapat diubah 5 6 // variabel instan

7 double radius;

57


8

9 double xCenter; 10 double yCenter; 11 double zCenter; 13 14 //class constructor 15 Bola(){ 16 17 } 18 19 //class constructor 20 Bola(double myRadius, double x, double y, double z){

21 radius = myRadius; 22 23 xCenter = x; 24 yCenter = y; 25 zCenter = z; 26 27 count ++; 28 } 29 30 31 //method static yang melaporkan jumlah bola 32 static int getCount(){

33 return count; 34 } 35 36 //method instan untuk menghitung volume 37 double volume(){ 38

39 return 4.0/3.0*PI*radius*radius*radius; 40 } 41 } 42

43 public class MainBola{ 44 public static void main(String[] args){ 45 double radius = 1.2; 46 double x = 1.3;

47 double y = 1.4; 48 double z = 1.1; 49 50 System.out.println("Jumlah bola adalah : " + Bola.getCount()); 51 Bola myBola = new Bola(radius, x, y, z); 52 System.out.println("Jumlah bola adalah : " + Bola.getCount()); 53 System.out.println("Volume bola : " + myBola.volume()); 54 55 Bola bola = new Bola(); 56 bola.radius = 2.4; 57 bola.xCenter = 3.5; 58 bola.yCenter = 4.5; 59 bola.zCenter = 1.6; 60

58


61 System.out.println("================================="); 62 System.out.println("Jumlah bola setelah bola ke dua adalah : " + Bola.getCount()); 63 System.out.println("Volume bola : " + bola.volume()); 64 System.out.println("Nilai variabel radius bola pertama : " + myBola.radius); 65 System.out.println("Nilai variabel radius bola kedua : " + bola.radius); 66 } 67 }

Pada contoh 4.13 diberikan dua contoh constructor dari class Bola, yaitu pada baris 15

merupakan constructor yang tidak memiliki parameter, sedangankan pada baris 20

constructornya memiliki 4 paramater. Dalam pembuatan objek instansiasi class Bola

dapat dibentuk berdasarkan bentuk constructor yang kita bentuk. Pada constructor baris

15 kita implementasikan seperti yang ditunjukkan pada baris 55, dimana setiap nilai

variabel instan dapat kita berikan setelah objeknya terbentuk. Java telah membuat

constructor yang tidak memiliki paramter seperti pada baris 15 walaupun kita tidak

membuatnya secara eksplisit. Pada constructor baris 20 saat kita membuat objek

instansiasi class Bola, kita harus memberikan nilai parameter yang dimiliki oleh ojek

yang akan kita bentuk. Perlu diperhatikan juga bahwa constructor pada baris 15 dan baris

20 tidak memiliki tipe parameter dan nama constructor diawali dengan huruf besar.

Adapun hasil yang diperoleh dari eksekusi source code contoh 4.13 adalah seperti yang

ditunjukkan pada gambar 4.4 dibawah ini.


59


4.9 Overloading Method

Saat kita ingin membuat beberapa method dengan nama yang sama, tetapi dengan

daftar parameter yang berbeda, maka kita telah membuat overloading method. Seperti

yang dibahas pada bab 2 bahwa Overloading method digunakan untuk melayani sifat

polimorfik Java.

Untuk memberikan pemahaman tentang pembuatan overloading method kita akan

membahwa penggalan source code pada contoh 4.14 dibawah ini. Pada penamaan

method volume dideklarasikan dua kali yang pertama tanpa parameter sedangkan yang

kedua dengan parameter myRadius.

Contoh 4.14 :

//method instan untuk menghitung volume double volume(){

return 4.0/3.0*PI*radius*radius*radius; } // overloading method double volume(double myRadius){ System.out.println("Dalam method overloading");

return 4.0/3.0*PI*myRadius*myRadius*myRadius; }

Bola myBola = new Bola(); System.out.println("Volume bola : " + myBola.volume()); System.out.println("Volume bola : " + myBola.volume(13.9));

4.10 Inheritance

Inheritansi adalah konsep yang memetakan hubungan class dengan class lainnya

secara hirarkis. Ini memungkinkan turunan dari suatu class mewarisi semua variabel dan

method dari ‘moyangnya’ dan juga miliknya sendiri. Untuk memberikan pemahaman

tentang pengimplementasian inheritansi pada Java dapat kita perhatikan seperti yang

ditunjukkan pada contoh 4.16 yang merupakan class yang mewarisi class superclass

contoh 4.15 dengan driver class pada contoh 4.17.

Contoh 4.15 :

/* * Nama File : Bola.java

60


* Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class Bola{ 2

3 public static final double PI = 3.14; // variabel class dengan nilai yang tetap 4 public static int count = 0; // variabel class yang nilainya dapat diubah 5 7 // variabel instan

8 public double radius; 9 10 public double xCenter;

11 public double yCenter;

12 public double zCenter; 13 14 //class constructor 15 public Bola(){

16 this.xCenter = 1.2;

18 this.yCenter = 2.3; 19 this.zCenter = 2.7; 20 this.radius = 7.0;

21 } 22

23 public void Bola(double xCenter, double yCenter, double zCenter){ 24 this.xCenter = xCenter; 25 this.yCenter = yCenter;

26 this.zCenter = zCenter; 27 System.out.println("Test"); 28 29 } 30 //class constructor 31 public Bola(double myRadius, double x, double y, double z){ 32 radius = myRadius; 33 34 xCenter = x; 35 yCenter = y; 36 zCenter = z; 37 38 System.out.println("================="); 39 count ++; 40 } 41 42 43 44 //method static yang melaporkan jumlah bola

45 public static int getCount(){ 46 return count; 47 } 48 49 //method instan untuk menghitung volume

61


50 public double volume(){ 51 52 return 4.0/3.0*PI*radius*radius*radius; 53 } 54 55 // overloading method 56 public double volume(double myRadius){ 57 System.out.println("Dalam method overloading"); 58 return 4.0/3.0*PI*myRadius*myRadius*myRadius; 59 } 60 61 }

Contoh 4.16 :

/* * Nama File : BolaBasket.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class BolaBasket extends Bola{

2

3 static final double PI = 3.14; // variabel class dengan nilai yang tetap 4 static int count = 0; // variabel class yang nilainya dapat diubah 5 6 // variabel instan

7 double radius; 8

9 double xCenter; 10 double yCenter; 11 double zCenter; 12 13 //class constructor 14 BolaBasket(){ 15 16 } 17 18 //class constructor

19 BolaBasket(double myRadius, double x, double y, double z){ 20 radius = myRadius; 21 22 xCenter = x; 23 yCenter = y; 24 zCenter = z; 25 } 26 }

Contoh 4.17 :

/* * Nama File : MainBolaBasket.java

62


* Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class MainBolaBasket{ 2 public static void main(String[] args){ 3 4 BolaBasket myBolaBasket = new BolaBasket(); 5 6 System.out.println("Volume bola : " + myBolaBasket.volume()); 7 System.out.println("Volume bola : " + myBolaBasket.volume(13.9)); 8 } 9 }

Pada listing code contoh 4.16 class BolaBasket merupakan sub-class dari super class

Bola, sehingga setiap variabel dan method yang dimiliki oleh class Bola akan diwarisi ke

sub-class BolaBasket. Pada pengimplementasian inheritans dalam Java dinyatakan

dengan kata kunci extends seperti yang dinyatakan pada baris 1 contoh 4.16.

Gambar 4.6 Hasil eksekusi program driver contoh 4.17

Pada driver mainBolaBasket pada contoh 4.17 baris 4 kita membentuk suatu

objek myBolaBasket dari class BolaBasket. Saat kita membentuk objek dari class

BolaBasket maka driver akan mengeksekusi baris 14 contoh 4.16 sehingga objek

myBolaBasket akan memiliki semua attribut dan method yang dimiliki oleh class

BolaBasket. Karena class BolaBasket merupakan turunan (extends) dari class Bola

maka objek myBolaBasket juga akan mewarisi (inheritance) semua attribut dan method

63


yang dimiliki oleh class Bola akibatnya objek myBolaBasket akan memiliki attribut

radius dengan nilai 7 sesuai dengan nilai pada baris 20 contoh 4.15. Pada baris 6 contoh

4.17 driver class MainBolaBasket kita membutuhkan method volume( ) yang dimiliki

oleh superclass Bola. Karena nilai radius diinisialisasi dengan nilai 7, seperti nilai pada

baris 20 contoh 4.15, maka diperoleh nilai volume adalah 1436.02666666 yang diperoleh

dengan memanggil blok method volume( ) baris 50 samapai 53 pada contoh 4.15.

Pada baris 7 contoh 4.17 objek myBolaBasket memanggil method volume() untuk

menghitung volume dengan nilai argumennya adalah 13.9. Karena nilai parameter

diberikan, maka method yang dipanggil adalah method pada baris 56 samapai 57 pada

contoh 4.15. Method ini merupakan method overloading dari method volume( ) pada

baris 50 sampai 53. Adapun hasil eksekusi dari driver listing program contoh 4.17 adalah

seperti yang ditunjukkan pada gambar 4.6.

4.11 super

Pada Java terdapat variabel khusus yang disebut super, yang digunakan untuk

merujuk langsung ke constructor superclass-nya. Penggunaan kata kunci super seakan-

akan kita meng-copy-kan constructor yang ada pada superclassnya, hal ini akan lebih

menghemat pengalokasian memori dan penulisan coding. Pada penggunaan kata kunci

super perlu memperhatikan pendeklarasian variabel pada classnya. Variabel yang

digunakan pada superclass yang akan kita rujuk constructornya sebagai super class tidak

diperbolehkan mendeklarasikan variabel yang sama pada classnya. Untuk memberikan

pemahaman tentang penggunaan super kita akan membahas source code seperti yang


Contoh 4.18 :

/* * Nama File : Point.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class Point{ 2 int x, y; 3

64


4 Point(int x, int y){

5 this.x = x; 6 this.y = y; 7 } 8 Point(){

9 this(8, 10); 10 } 11 }

Contoh 4.19 :

/* * Nama File : Point3D.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class Point3D extends Point{

2 int z; 3 4 Point3D(int x, int y, int z){

5 super(x,y);

6 this.z = z; 7 } 8 }

Contoh 4.20 :

/* * Nama File : MainPoint.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MainPoint{ 2 public static void main(String[] args){ 3 4 Point3D point = new Point3D(1,3,7); 5 6 System.out.println("Nilai titik x :" + point.x + " nilai y : " 7 + point.y + " nilai z : " + point.z); 8 } 9 }

Pada driver MainPoint contoh 4.20 kita perhatikan bahwa pada baris 4 driver

membentuk objek point dari class Point3D dengan nilai argument 1, 3, dan 7 yang

bersesuaian dengan parameter x, y, dan z pada constructor class Point3D pada baris 4

contoh 4.19. Karena pada baris 5 contoh 4.19 memanggil method super() maka class

65


Point3D akan memanggil constructor dari superclass-nya yaitu class Point pada contoh

4.18 pada baris 4. Adapun hasil eksekusi program driver contoh 4.20 akan diperoleh



Perlu diperhatikan bahwa pada baris 2 contoh 4.19, kita hanya mendeklarasikan

variabel z dengan tipe int . Agar penggunaan kata kunci super pada class Point3D dapat

berfungsi dengan baik, maka pada class Point3D pada contoh 4.19 tidak boleh

mendeklarasikan variabel x dan y. Jika pada contoh 4.19 kita menambah pendeklarasian

variabel dengan variabel x dan y, sehingga diperoleh potongan source code seperti contoh

4.21 maka akan diperoleh hasil pengeksekusian program seperti yang ditunjukkan pada

gambar 4.8.

Contoh 4.21

1 public class Point3D extends Point{

2 int z; 3 int x;

4 int y; 5 .

.

}

66


Gambar 4.8 Hasil eksekusi program driver contoh 4.20 dengan class contoh 4.21

4.12 Pengiriman method Dinamis

Pada pemrograman Java, untuk memanggil suatu method yang diperlukan oleh

suatu objek dapat dilakukan dengan menambahkan operator dot (.) pada objek kemudian

diikuti oleh method yang dibutuhkan. Saat dicompile maka compiler java akan

memastikan bahwa semua method yang dipanggil oleh suatu objek merujuk ke suatu

instan dari subclass yang telah dideklarasikan. Sehingga java menggunakan instan yang

ada untuk memutuskan method mana yang dipanggil saat subclass yang meng—override

dipanggil. Proses pemannggilan method ini disebut pengiriman method dinamis.

Pengiriman method dinamis yang dimaksud adalah compiler java secara dinamis

menentukan method yang dipanggil yang sesuai dengan instan dari subclass pada tipe

yang dideklarasikan. Untuk memberikan pemahaman terhadapa pengiriman method

dinamis kita akan membahas driver cource code yang diberikan pada contoh 4.24.

Contoh 4.22 :

/* * Nama File : A.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class A{ 2 void callme(){

67


3 System.out.println("Ini dalam class A"); 4 } 5 void callme(String comment){

6 System.out.println("Ini dalam class A dengan comment : " + comment); 7 } 8 }

Contoh 4.23 :

/* * Nama File : B.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class B extends A{ 2 void callme(){

3 System.out.println("Ini dalam class B"); 4 } 5 }

Contoh 4.24 :

/* * Nama File : MainTestPoli.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MainTestPoli{

2 public static void main(String[] args){ 3 A a = new B(); 4 a.callme(); 5 a.callme("Uji Polimorfisme"); 6 } 7 }

Pada listing code contoh 4.24 pada baris 3 kita lihat bahwa method main

mendeklarasikan tipe A, dari suatu instans yang mereferensi ke suatu instans dari class B.

Pada baris 4 contoh 4.24 objek a melakukan pemanggilan method callme(). Karena objek

a merupakan instan dari subclass B yang extends ke class A maka runtime Java akan

melihat bahwa referensi sebenarnya adalah method callme ( ) yang dimiliki oleh class B

pada baris 2, bukan milik A baris 2. Pada baris 5 contoh 4.24 objek a memanggil method

callme() dengan passing parameter “Uji Polimorfisme”. Karena ojek a dideklarasikan

sebagai tipe A maka saat objek a memanggil method callme( ) dengan passing parameter

68


“Uji Polimorfisme” sedangkan pada class B tidak terdapat method callme( ) akibatnya

method yang dipanggil adalah method callme ( ) contoh 4.22 pada baris 5. Kemampuan

runtime java di dalam menangani pemanggilan method yang sesuai merupakan salah satu

mekanisme yang ampuh dalam rancangan berorientasi objek. Kemampuan in disebut

dengan kemapuan polimorfisme. Adapun hasil eksekusi listing code contoh 4.22, contoh

4.23 dengan driver conoth 4.24 seperti yang ditunjukkan pada gambar 4.9.


4.13 Kata kunci final

Kita telah membahas pada subbab sebelumnya bahwa kita dapat meng-override

suatu method dan variabel pada suatu class. Tetapi dalam prakteknya terkadang kita

diperhadapkan dengan keadaan dimana suatu variabel memiliki nilai tertentu yang tidak

dapat diubah yang sering disebut dengan konstanta. Demikian juga halnya dengan suatu

method tidak diperbolehkan untuk meng-override method. Untuk penanganan kasus yang

seperti ini, kita cukup menambahkan kata kunci final pada method dan variabelnya.

Menurut kesepakatan bahwa penulisan program untuk semua identifier adalah

dengan huruf besar. Untuk memberikan pemahaman yang jelas tentang pendeklarasian

konstanta identifier dan pendeklarasian suatu method yang tidak dapat di-override

terlebih dahulu kita memperhatikan contoh penggunaan kata kunci final yang salah

seperti yang ditunjukkan pada contoh 4.25.

69


Contoh 4.25 :

1 /** File Name : A.java 2 * Create by : Jasman Pardede 3 * Create date : 4 * Description : 5 */ 6 7 8 public class A{ 9 final double PI = 3.14;

10 11 final void callme(){

12 System.out.println("Ini dalam class A"); 13 } 14

15 void callme(String comment){ 16 System.out.println("Ini dalam class A dengan comment : " + comment); 17 } 18 void setPI(double myPI){ 19 PI = myPI; 20 } 21 }

Contoh 4.26 :

1 /** File Name : B.java 2 * Create by : Jasman Pardede 3 * Create date: 4 * Description: 5 */ 6 7

8 public class B extends A{ 9 10 void callme(){


Pada baris 9 conoth 4.25 kita telah mendeklarasikan variabel PI dengan kata kunci final,

tetapi pada baris ke 19 kita berusaha untuk mengubah nilai variabel yang telah

dideklarasikan sebagai konstanta sehingga compiler java akan memberikan kesalahan

bahwa variabel PI pada baris 19 telah dideklarasikan sebagai final . Begitu juga dengan

method callme() pada baris 10 class B kita berusaha untuk meng-override method

callme() yang telah dideklarasikan sebagai final pada class A yang merupakan superclass

dari B, akibatnya compiler java akan memberikan kesalahan bahwa method callme tidak

70


dapat dioverride karena telah dideklarasikan final. Adapun hasil eksekusi program contoh

4.25 dan contoh 4.26 dengan driver contoh 4.24 seperti yang ditunjukkan pada gambar

4.10.

Gambar 4.10 Hasil eksekusi program driver contoh 4.24 dengan class A dan B

Untuk memperbaiki kesalahan yang terjadi, maka kita harus menghilangkan method

setPI() pada baris 18-20 pada contoh 4.25 dan menghapus kata kunci final pada method

callme() baris 11. Sehingga diperoleh source code program seperti pada contoh 4.27.

Contoh 4.27:

/* * Nama File : MainTestFinal.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class A{ 2 final double PI = 3.14; 3

4 void callme(){ 5 System.out.println("Ini dalam class A"); 6 } 7 8 final void callme(String comment){ 9 System.out.println("Ini dalam class A dengan comment : " + comment); 10 } 11 }

71


12

13 public class B extends A{ 14 15 void callme(){


19 public class MainTestFinal{ 20 public static void main(String[] args){ 21 A a = new B(); 22 a.callme(); 23 a.callme("Uji Polimorfisme"); 24 System.out.println("nilai konstanta PI : " +a.PI); 25 } 26 }

Adapun hasil eksekusi program dari contoh 4.27 adalah seperti yang ditunjukkan pada

gambar 4.11.

Gambar 4.11 Hasil eksekusi program driver MainTestFinal contoh 4.27

4.14 Kata kunci static

Kata kunci static pada Java digunakan untuk mendeklarasikan semua variabel dan

method sebagai variabel dan method global yang dapat diakses oleh sembarang bagian

program. Pendeklarasian method static hanya memperbolehkan pemanggilan method

static lain secara langsung karena itu method static tidak boleh merujuk ke this atau

super.

72


Method dan variabel yang dideklarasikan sebagai static akan dapat dipanggil

langsung dengan merujuk nama class yang diikuti dengan nama method dan variabel

yang akan dipanggil. Pendeklarasian blok static hanya akan dieksekusi sekali yaitu saat

pemanggilan class yang pertama. Untuk memberikan pemahaman tentang kata kunci

static kita akan membahas contoh 4.28.

Contoh 4.28 :

/* * Nama File : ContohStatic.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class ContohStatic{ 2 static int a = 26; 3 static int b; 4 5 static void printVariabel(int myX){ 6 System.out.println("nilai masukan x " + myX); 7 System.out.println("nilai konstanta " + a); 8 System.out.println("nilai penjumlahan a dan x " + b); 9 } 10 11 static{ 12 System.out.println("Blok perhitungan nilai b secara static"); 13 b = 9*a; 14 } 15 16 public static void main(String args[]){ 17 printVariabel(1978); 18 } 19 20 }

Pada contoh 4.28 setelah class ContohStatic dipanggil, maka interpreter Java akan

menginisialisasi semua variabel yang dideklarasikan sebagai static, yaitu nilai a sama

dengan 26 sedangkan nilai b dinisialisasi dengan pemanggilan block static pada baris 11

sampai 14, yaitu nilai b diinisialisasi dengan 9*a. Karena a adalah variabel static dengan

nilai 26 maka b diisi dengan nilai 234. Setelah semua variabel static diinisialisasi maka

interpreter akan mengeksekusi method main pada baris 16 dengan memanggil method

printVariabel () dengan nilai passing parameter 1978. Karena method printVariabel ()

73


pada baris 5 dideklarasikan sebagai static sehingga method dapat dipanggil. Interpreter

java pertama sekali menginisialisasi variabel static dapat kita lihat dengan

memperhatikan hasil eksekusi program, dimana komentar “Blok perhitungan nilai b

secara static” yang pertama sekali ditampilkan bukan “nilai masukan x“. Adapun hasil

eksekusi program dari contoh 3.28 adalah seperti yang ditunjukkan pada gambar 4.12.


4.15 Kata kunci finalize

Salah satu keunggulan Java adalah bebas dari penumpukan sampah, dimana

dengan runtime Java kita tidak perlu dicemaskan tentang pembebasan memori yang telah

dialokasikan. Tetapi runtime java hanya mampu untuk membebaskan pengalokasian

memori yang bersifat objek Java. Pada kenyataannya kita sering memerlukan

pengaksesan sejumlah program khusus saat objek sedang dikumpulkan oleh pengumpul

sampah, yaitu mengakses objek yang bukan merupakan objek Java (objek non-java),

seperti penangan file dan sistem font window. Untuk membebaskan pengalokasian

memori terhadap objek non-Java ini kita menggunakan kata kunci finalize pada method

yang mengakses objek non-java sehingga akan menjamin bahwa pengalokasi memori

terhadap objek non-java tersebut telah dibebaskan.

74


Dengan adanya kata kunci finalize pada method suatu class, maka sebelum suatu

bagian dibebaskan, runtime Java akan memanggil method finalize untuk membebaskan

objek non-java yang digunakan oleh method tersebut.

4.16 Abstract

Pada bab sebelumnya telah diungkapkan bahwa didalam pengembangan

perangkat lunak berorientasi objek kita memandang setiap domain permasalahan sebagai

suatu objek. Objek yang besar kita lihat kebagian yang lebih detail menjadi objek yang

lebih kusus sampai didapatkan objek yang paling sederhana. Objek yang besar akan

menggambarkan domain permasalahan secara global sehingga objek yang besar di dalam

pendeklarasiannya akan menjadi sebagai suatu abstrak.

Suatu keadaan di mana kita perlu mendefinisikan class tertentu tanpa

menyediakan implementasi lengkap dari setiap method maka class tersebut kita

deklarasikan sebagai struktur abstraksi dan class yang kita bentuk disebut dengan class

abstrak. Untuk mengimplemtasikan methodnya dilakukan dengan meng-override pada

subclass-nya sedangkan pada tipe method parent dideklarasikan dengan kata kunci

abstract. Dengan kata lain semua class yang berisi method yang hendak dideklarasikan

sebagai method abstract maka class tersebut harus dideklarasikan sebagai class abstract,

yaitu menambahkan kata kunci abstract di depan deklarasi class. Karena implementasi

lengkap dari method pada suatu class abstract belum didefinisikan secara lengkap maka

class abstract tidak dapat secara langsung diolah operator new.

Karena pengimplementasian semua method abstract yang ada pada class abstract

hanya pada subclass yang menggunakan class abstract maka class abstract tidak dapat

mendeklarasikan method static dan constructor. Untuk memberi pemahaman yang jelas

tentang kata kunci abstract kita akan membahas contoh seperti yang diberikan pada

contoh 4.28, contoh 4.29 dengan driver contoh 4.30 .

Contoh 4.28 :

/* * Nama File : A2.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java

75


* @version 1.1 */

1 abstract class A2{ 2 3 abstract void callmeAbs();

4 { 5 System.out.println("Ini dalam class A2 callmeAbs"); 6 } 7 8 9 // bukan method abstract 10 static void callme(){ 11 System.out.println("Ini dalam class A2 callme() "); 12 } 13

14 void callme(String myData){ 15 System.out.println("Ini dalam class A2 :" + myData); 16 } 17 18 abstract void printer();{

19 System.out.println("Hello"); 20 } 22 abstract void testMethod();{ 23 System.out.println("Dalam class abstract method testMethod"); 24 } 25 }

Contoh 4.29 :

/* * Nama File : B2.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class B2 extends A2{ 2 3 void callmeAbs(){

4 System.out.println("Ini dalam class B"); 5 System.out.println(" ====================== "); 6 callme(); 7 System.out.println("++++++++++++++++++++++"); 8 callme("Data dalam B2"); 9 } 10 11 void callme(String myData){

12 System.out.println("Ini dalam class B2 : " + myData); 13 }

14 static void B2(){

76


15 System.out.println("Ini B2"); 16 } 17 18 void printer(){ 19 System.out.println("Hello B"); 20 } 21 22 void testMethod(){ 23 System.out.println("Ini dalam class B bukan abstract "); 24 } 25 26 }

Contoh 4.30 : /* * Nama File TestAbstract.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class TestAbstract{ 2 public static void main(String[] args){ 3 B2 b = new B2(); 4 5 b.callmeAbs(); 6 } 7 }

Pada class A2 kita mendefinisikan tiga buah method sebagai method abstract, yaitu pada

baris 3, 18, dan 22 sedangkan untuk mendefinisikan class A2 sebagai class abstract

didefinisikan dengan kata kunci abstrast seperti yang ditunjukkan pada baris 1 contoh

4.28. Untuk mengimplementasikan semua method abstract pada class A2 pada class B2

yang merupakan sublcass dari class A2 diimplementasikan seperti yang ditunjukkan pada

baris 3, 18, dan 22 pada contoh 4.29. Pembuatan method abstact selalu diidentifikasi

dengan tanda semi kolom (;) seperti yang dinyatakan pada method abstract class A2.

Dengan mengeksekusi driver contoh 4.30 kita perhatikan bahwa pada baris 5 setelah

objek b dari class B2 terbentuk, runtime java memanggil method callmeAbs() yang

dimiliki oleh class B2, hal ini akan memanggil method callmeAbs() baris 3 class B2.

Karena class B2 merupakan subclass dari class abstract A2 maka runtime Java akan

pertama sekali mengeksekusi semua method yang dideklarasikan sebagai method abstract

pada class abstract A2 yaitu method pada baris 3, 18 dan 22 contoh 4.29 secara berurutan,

kemudian mengeksekusi baris perintah yang ada pada methodnya. Pada baris 6 contoh

77


4.29 memanggil method callme(), karena merupakan subclass dari class A2 maka akan

mengeksekusi baris 10 contoh 4.28. Kemudian akan dilanjutkan dengan mengeksekusi

baris 8 yang memanggil method callme() baris 10. Adapun hasil eksekusi program dari

contoh 4.30 adalah seperti yang ditunjukkan pada gambar 4.13.


4.17 Penggunaan Package

Package adalah dasar pemrograman Java, sehingga kita perlu memahami konsep

package. Suatu package adalah suatu nama yang menyimpan sekumpulan class-class.

Tujuan dari pengelompokan class-class dalam suatu package adalah untuk membuat

kemudahan dalam menambahkan class-class dalam suatu package dan memudahkan

dalam memasukkan code program yang kita buat ke dalam suatu class tertentu. Nama

suatu class yang dimasukkan dalam suatu package tidak akan mempengaruhi nama class

yang berada pada package yang berbeda atau program yang kita buat, karena nama class

pada suatu package diidentifikasi berbasarkan nama package.

Setiap class pada Java di simpan pada suatu package. Misalkan saat kita

mengguanakan class String pada program Java kita kita harus mengimport java.lang. Ini

dimaksudkan bahwa String disimpan pada package java.lang

78


4.17.1 Pernyataan package

Penyimpanan class-class Java pada suatu package sangat sederhana, yaitu hanya

dengan menambahkan suatu statement package pada baris pertama source code Java yang

kita buat. Pendeklarasian suatu package terdiri dari kata kunci package yang diikuti

dengan nama packagenya dan diakhiri dengan tanda titik-koma, seperti yang ditunjukkan

pada contoh 4.31 di bawah ini.

Contoh 4.31 :

package ruang;

public class Bola{

}

Pada contoh 4.31 menunjukkan bahwa nama package-nya adalah ruang. Jika kita ingin

class-class yang ada di dalam suatu package dapat diakses oleh class lain berada di luar

package kita, maka class-class tersebut kita deklarasikan dengan kata kunci public. Setiap

class yang ingin disimpan pada package yang sama, misalkan package ruang, maka

class-class tersebut harus dimulai dengan statement package yang sama, yaitu ruang.

Suatu class yang tidak dideklarasikan dengan public tidak dapat diakses dari package

lain.

4.17.2 Package dan Struktur Direktori

Suatu package berhubungan dengan struktur direktori dimana class-class tersebut

disimpan. Suatu package bukanlah hanya memiliki nama tunggal. Kita dapat

menspesifikasi suatu package dengan nama direktori sekuens linear. Jika kita ingin

menyimpan class Java pada direktori oop yang berada di dalam direktori classObject,

maka pada class tersebut kita deklarasikan dengan nama root direktori diikuti dengan

subdirektori dimana class tersebut disimpan, seperti yang dinyatakan pada contoh 4.32

berikut;

Contoh 4.32 :

package classObject.ruang;

79


public class Bola{

:

:

}

ini menunjukkan bahwa class Bola disimpan pada direktori classObject yang

mengandung direktori oop.

4.17.3 Penggunaan Class-Class dari suatu Package ke suatu Program

Untuk menggunakan variabel dan method yang dimiliki class-class dalam suatu

package kepada suatu program dapat dilakukan dengan menggunakan statement import.

Misalkan jika kita ingin menggunakan class yang ada di package ruang ke suatu class

tertentu, kita hanya dengan menambahkan statement import seperti yang dinyatakan pada

contoh 4.33.

Gambar 4.14 Penamaan direktori di dalam pengaksesan package

Contoh 4.33 :

import ruang.*;

public class namaClass { // nama class yang menggunakan class –class

// yang ada pada package ruang

80


:

:

}

Di dalam penyimpanan file (source code) yang akan digunakan di dalam package ruang,

maka harus disimpan di dalam direktori dengan nama direktori adalah ruang. Mengingat

java yang case-sensitive maka perlu diperhatikan bahwa di dalam penamaan direktori

harus persis sama dengan nama package yang akan kita gunakan. Misalkan jika kita

hendak menggunakan nama package-nya adalah ruang maka nama direktorinya adalah

ruang, seperti yang ditunjukkan pada gambar 4.14.

Untuk memberikan pemahaman tentang penggunaan package didalam

pemrograman java akan diberikan source code seperti yang ditunjukkan pada contoh 4.34

listing code di bawah ini;

Contoh 4.34 :

1 /** File Name : Bola.java 2 * Create by : Jasman Pardede 3 * Create date : 4 * Description : 5 */ 6 7 package ruang; 8

9 public class Bola{ 10 11 public static final double PI = 3.14; // variabel class dengan nilai yang tetap

12 public static int count = 0; //variabel class yang nilainya dapat diubah 13 14 // variabel instan

15 public double radius; 16 17 public double xCenter; 18 public double yCenter;

19 public double zCenter; 20 21 //class constructor

22 public Bola(){ 23 this(1.2, 2.3, 2.7); 24 } 25 26 public Bola(double xCenter, double yCenter, double zCenter){

27 this.xCenter = xCenter;

81


28 this.yCenter = yCenter; 29 this.zCenter = zCenter; 30 System.out.println("Test"); 31 } 32 33 //class constructor 34 public Bola(double myRadius, double x, double y, double z){ 35 radius = myRadius; 36 xCenter = x; 37 yCenter = y; 38 zCenter = z; 39 count ++; 40 } 41 42 //method static yang melaporkan jumlah bola

43 public static int getCount(){

44 return count; 45 } 46 47 //method instan untuk menghitung volume 48 public double volume(){

49 return 4.0/3.0*PI*radius*radius*radius; 50 } 51 52 // overloading method 53 public double volume(double myRadius){ 54 System.out.println("Dalam method overloading");

55 return 4.0/3.0*PI*myRadius*myRadius*myRadius; 56 } 57 58 }

Contoh 4.35

1 /** File Name : BolaBasket.java 2 * Create by : Jasman Pardede 3 * Create date : 4 * Description : 5 */ 6 7 package ruang; 8 9 public class BolaBasket extends Bola{ 10

11 public static final double PI = 3.14; // variabel class dengan nilai yang tetap

12 public static int count = 0; // variabel class yang nilainya dapat diubah 13 // variabel instan

14 public double radius; 15 16 public double xCenter;

82


17 public double yCenter; 18 public double zCenter; 19 20 //class constructor 21 public BolaBasket(){ 22 } 23 24 //class constructor dengan penggunaan super 25 BolaBasket(double myRadius, double x, double y, double z){ 26 super(x, y, z);

27 this.radius = myRadius; 28 } 29 30 }

Contoh 4.36 :

/* * Nama File : TestPoint.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 package ruang; 2

3 public class TestPoint{ 4 public int x, y; 5 6 public TestPoint(int x, int y){ 7 this.x = x;

8 this.y = y; 9 } 10 11 public TestPoint(){

12 this(1, 3); 13 } 14 }

Contoh 4.37

1 /** File Name : MainBolaBasketPackage.java 2 * Create by : Jasman Pardede 3 * Create date : 5 * Description : 6 */ 7 8 import ruang.*; 9 10 public class MainBolaBasketPackage{ 11 public static void main(String[] args){ 12

83


13 BolaBasket bola = new BolaBasket(1.2, 3.4, 2.5, 3.6); 14 15 System.out.println("Volume bola : " + bola.volume()); 16 System.out.println("Volume bola : " + bola.volume(13.9)); 17 System.out.println("jari-jari x : " + bola.xCenter + " jari-jari y : " + bola.yCenter ); 18 System.out.println("Radiusnya : " + bola.radius); 19 System.out.println("Volume bola basket yang dioverloading : " + 20 bola.volume(bola.radius)); 21 22 TestPoint point = new TestPoint(); 23 System.out.println("inisialisasi awal " + point.x); 24 } 25 }


Dari contoh 4.37 kita perhatikan bahwa pada baris 13 driver MainBolaBaskectPackage

membentuk objek bola dari instansiasi class BolaBasket. Karena driver

MainBolaBaskectPackage menambahkan statement import ruang.*; maka semua class

yang ada pada package ruang yang dapat diakses oleh driver MainBolaBasketPackage,

akibatnya akan driver akab memanggil class contoh 4.35 baris 25. Kita perhatikan bahwa

pada baris 26 contoh 4.35 menggunakan kata kunci super, yang akan mengakibatkan

class BolaBasket akan memanggil construktor parentnya, yaitu class Bola contoh 4.34

baris 26. Saat driver mengeksekusi baris 15, maka akan memanggil method baris 48

contoh 4.35, kemudian driver mengeksekusi baris 16, yang mengakibatkan pemanggilan

method baris 48 contoh 4.34. Saat driver mengeksekusi baris 22, maka akan memanggil

class TestPoint contoh 4.36 untuk membentuk objek point kemudian memanggil method

84


class Point pada baris 11 yang akan memberikan nilai default x sama dengan 1 dan y

sama dengan 3. Adapun hasil eksekusi dari listing program contoh 4.37 adalah seperti

yang ditunjukkan pada gambar 4.15.

4.18 Antarmuka (Interface)

Interface Java dirancang untuk mendukung resolusi method dinamik saat program

berjalan. Pada saat program di compile dan membaca adanya method dari suatu class ke

class yang lain maka kedua class tersebut harus ada sehingga compiler Java dapat

memastikan apakah pengenal method sudah cocok.

Interface sangat mirip dengan class, tetapi pada interface tidak diperbolehkan

pendeklarasian variabel instan dan method pada interface dideklarasikan tanpa

memberikan implementasi terhadap method yang kita deklarasikan. Artinya, secara

praktek kita dapat mendefinisikan interface tanpa merujuk rincian implementasinya.

Pada pengimplemtasian interface hanya dilakukan pada class yang

menggunakannya. Suatu class dapat mengimplementasikan sejumlah antarmuka. Dengan

kata lain, suatu class dapat mengimplementasikan lebih dari satu interface. Bentuk

umum dari pernyataan interface adalah seperti yang ditunjukkan dibawah ini;

iterface nameInterface{ return-type method-name(parameter-list); type final-varname = value; }

Perhatikan bahwa method yang dideklarasikan pada bentuk umum interface tidak

memiliki isi, tetapi diakhiri dengan tanda titik koma setelah daftar parameter. Sehingga

tidak ada implementasi default untuk sebuah antarmuka tetapi yang ada hanya daftar

method. Saat sebuah class mengimplementasikan suatu interface maka setiap method

yang ada pada interface harus diimplementasikan dengan pengenal tipe yang benar-benar

cocok dengan tipe yang dideklarasikan pada interface-nya. Jika suatu class

mengimplementasikan lebih dari satu antarmuka, maka antarmuka tersebut dipisahkan

dengan tanda koma. Class yang mengimplementasikan sejumlah interface memiliki

bentuk umum sebagai berikut:

Class className [extends superclass] [implements interface1, interface2,...]{

85


}

Untuk memberikan pemahaman yang lebih jelas tentang penggunaan interface pada suatu

class kita akan memperhatikan contoh 4.38 yang diberikan dengan class yang

mengimplemtasikannya seperti pada contoh 4.39.

Contoh 4.38 :

/* * Nama File : ICommand.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 package ruang; 2 3 4 public interface ICommand { 5 // The list of command type ids 6

7 public static final short ERROR = 27; 8 public static final short TEST = 28; 9 public static final short MESSINFOSPEAK = 29; 10 public static final short Salah = 30;

11 public static final short MESSINFOCANVAS = 31;

12 public static final short MESSINFOCANCANVAS = 32; 13 public static final short MAKEVERSION = 33; 14 public static final short CLOSEVERSION = 34; 15 16 // Activity subtypes

17 public static final short ACTIVITY_TYPING = 1; 18 public static final short ACTIVITY_DRAWING = 2; 19 20 // Error subtypes

21 public static final short ERROR_NOPAGE = 1; 22 public static final short ERROR_NOSOUND = 2; 23 24 public void hitung();

25

26 public int hitung(int x, int y); 27 28 }

86


Contoh 4.39:

/* * Nama File : MainInterface.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import ruang.*; 2 public class MainInterface implements ICommand{

3 public static void main(String[] args){ 4 System.out.println("Nilai yang dimasukkan : "); 5 answer(30); 6 System.out.println(); 7 answer(31); 8 MainInterface mainInt = new MainInterface(); 9 mainInt.hitung(); 10 System.out.println(" Nilai C = " + mainInt.hitung(3,6)); 11 } 12 public void hitung(){

13 byte x = 8; 14 byte y = 3; 15 byte z; 15 z = (byte)(x*y); 16 System.out.println("Nilai z : " + z); 17 } 18 public int hitung(int x, int y){ 19 int z; 20 z = x*y;

21 return z; 22 } 23 static void answer(int input){

24 switch(input){ 25 case ERROR: 26 System.out.println("ERROR"); 27 break;

28 case TEST: 29 System.out.println("TEST"); 30 break;

31 case MESSINFOSPEAK: 32 System.out.println("MESSINFOSPEAK");

33 break; 34 case CLOSEVERSION: 35 System.out.println("CLOSEVERSION");

36 break; 37 case Salah: 38 System.out.println("Ini Salah");

39 break; 40 case MESSINFOCANVAS: 41 System.out.println("ini dalam MESSINFOCANVAS");

87


42 break; 43 } 44 } 45 }

Gambar 4.17 Hasil eksekusi contoh 4.39 dengan method hitung() tidak diimplentasikan

Andaikan kita menghilangkan method hitung() yang diimplementasikan pada baris 12

sampai 17 dan menghilangkan baris 18 contoh 4.39, maka ini berarti bahwa kita tidak

mengimplementasikan method yang telah dideklarasikan pada interface baris 24 contoh

4.38. Saat terdapat suatu method yang tidak diimplemtasikan pada class yang

mengimplemtasikan interface maka compiler java akan menemukan suatu kesalahan,

seperti yang diberikan pada gambar 4.16.

Jika kita mengimplemtasikan semua method yang telah dideklarasikan pada interface

seperti yang ditunjukkan pada source code program contoh 4.39 maka saat kita meng-

compile class java tidak akan ditemukan adanya kesalahan.

Pada baris 5 contoh 4.39, aplikasi memanggil method static answer() dengan nilai

argumennya 30. Akibatnya, akan memanggil method pada baris 23 contoh 4.39. Saat

memasuki blok switch runtime java akan mencari nilai yang sesuai dengan 30. Karena

class MainInterface mengimplementasikan interface Command yang ada package ruang,

maka runtime Java akan mengakses objek Command, untuk menentukan nilai 30 yang

sama dengan argumen “Salah“. Kemudian runtime Java akan mencocokkan nilai yang

sama dengan argumen “Salah”, dan ternyata sama dengan case 30 akibatnya, runtime

Java akan mengeksekusi informasi “Ini salah” yang ada pada baris pada 38. Adapun

88


hasil eksekusi dari listing program contoh 4.39 adalah seperti yang ditunjukkan pada

gambar 4.17 .

Gambar 4.17 Hasil eksekusi contoh 4.39 dengan semua method diimplentasikan

89


Soal Latihan Bab 4. 1. Apa yang dimasuksud dengan variable class dan variable instant?

2. Jelaskan perbedaan antara method class dengan menthod instant.

3. Jelaskan cara pengakasesan suatu variable dan method. Berikan contoh masing-

masing.

4. Jelaskan pendefinisian suatu class dan suatu method pada suatu class. Berikan

contohnya.

5. Apa yang dimaksud dengan constructor?

6. Apa yang dimaksud dengan static?

7. Jelaskan perbedaan antara parameter dengan argument. Berikan contohnya.

8. Apa yang dimaksud dengan pass-by-value? Berikan contohnya.

9. Apa yang dimaksud dengan overloading method dan berikan contohnya.

10. Apa yang dimaksud dengan blok inisialisasi?

11. Apa yang dimaksud dengan package?

12. Jelaskan keuntungan penggunaan package?

90


Bab 5 Tipe-Tipe Data pada Java

Tipe adalah pengelompokan berdasarkan isi dan sifat. Pada pemrograman

komputer, tipe mendefinisikan pernyataan atau variabel dengan sesuatu yang dapat

menunjukkan sifatnya.

5.1 Data dan Variabel

Variabel adalah suatu nama yang disimpan pada suatu bagian memori dan

digunakan untuk menyimpan informasi dalam program Java. Setiap variabel yang kita

definisikan hanya mampu menyimpan suatu tipe tertentu. Misalnya, jika kita

mendefinisikan variabel menyimpan tipe integer, maka variabel tersebut tidak dapat

digunakan untuk menyimpan variable desimal atau tipe yang lainnya. Jika kita

mendefinisikan suatu variabel dengan tipe objek mahasiswa, maka variabel tersebut

hanya dapat menyimpan objek mahasiswa tetapi tidak dapat digunakan untuk menyimpan

objek diluar mahasiswa.

Saat kita menggunakan suatu variabel pada suatu program maka saat program

tersebut kita jalankan, kompiler hanya mampu untuk memeriksa tipe variabel yang telah

kita definisikan. Secara eksplisit data yang diberikan pada nilai variabel dalam suatu

program disebut literals. Setiap literal juga memiliki tipe data tertentu.

Sebeleum kita dapat menggunakan suatu variabel kita terlebih dahulu

mendefinisikan nama dan tipe khusus dari variabel tersebut dalam suatu pernyataan

deklarasi. Dalam pemberian nama variabel pada suatu program sangat bersifat fleksibel

atau bebas bentuk.

5.2 Nama Variabel

Nama yang pilih dalam pendefinisian suatu variabel atau nama yang digunakan

untuk mendefinisikan sesuatu di dalam program Java disebut identifier. Suatu identifier

diperbolehkan panjang, tetapi harus selalu dimulai dengan huruf, underscore ( _ ) atau

tanda dollar ( $ ).

91


Java merupakan bahasa yang case sensitive, yaitu sangat memperhatikan huruf

besar dan huruf kecil. Dalam pendefinisian variabel mahasiswa berbeda dengan

Mahasiswa. Dalam pendefinisian suatu variabel tidak diperbolehkan pakai spasi atau tab.

Misalkan dalam pendifinisian variabel Jasman Pardede, dapat digunakan dengan

JasmanPardede. Pada pemrograman Java tidak diperbolehkan mendefinisikan suatu

variabel yang diawali dengan suatu bilangan. Misalkan pendefisian variabel 10Up, dapat

kita definisikan dengan teenUp.

Dalam pendefinisian variabel pada Java tidak diperbolehkan menggunakan

keyword yang dimiliki oleh Java, seperti true, false, int, Date, addObserver, cancel,

static, void, print, dan lain-lain.

Secara umum penamaan variabel dilakukan dengan nama yang mendeskripsikan

data yang akan dimiliki oleh variabel tersebut dan menggunakan huruf kecil. Untuk

variabel yang terdiri dari dua suku kata atau lebih dapat dibuat dengan suku pertama

huruf kecil sedangkan suku kata berikutnya diawali dengan huruf besar kemudian huruf

kecil. Misalkan dalam pendefisian variabel yang terdisi dari dua suku kata, ipk

mahasiswa dapat dilakukan dengan ipkMahasiswa. Untuk variabel yang terdiri dari tiga

suku kata, nomor plat mobil dapat didefinisikan dengan noPlatMobil. Jika saudara

merasa perlu untuk mengetahui lebih dalam mengenai pendefinisian variabel dapat

suadara rujuk dari http://www.javasoft.com/docs/codeconv/.

5.3 Variabel dan Type

Seperti yang telah dijelaskan diatas, setiap variabel yang kita deklarasikan hanya

dapat menyimpan nilai dengan tipe data tertentu. Kita menggunakan variabel tertentu

dengan menggunakan tipe nama pada variabel deklarasi. Misalkan variabel jumlah

mahasiswa yang menyimpan nilai integer, dapat didefinisikan sebagai berikut :

int numberOfMhs;

Dalam hal ini tipe datanya adalah int, nama variabelnya adalah numberOfMhs,

tanda semi-colon (;) menyatakan akhir dari statement. Variabel numberOfMhs hanya

dapat menyimpan nilai yang ber-tipe int.

92


5.4 Tipe-Tipe Sederhana

Tipe sederhana mewakili pernyataan dasar bernilai tunggal, seperti integer, bilangan

pecahan (floating-point), karakter, dan besaran boolean. Java memiliki delapan tipe

sederhana : byte, short, int, long, char, float, double, dan boolean, yang dapat

dikelompokkan dalam 4 kelompok :

1. Integer : byte, short, int, dan long, semuanya berupa bilangan bulat bertanda.

2. Bilangan pecahan : float dan double, yang berupa bilangan pecahan

3. Karakter : char, mewakili simbol pada himpunan karakter

4. Boolean: boolean, yang merupakan tipe khusus untuk menunjukkan besaran

logika.

Pada beberapa bahasa, tidak ada pemaksaan atau konversi otomatis jika terjadi

ketidak cocokan. Compiler Java secara tetap memeriksa semua baris program yang di-

compile untuk memastikan bahwa semua menggunakan tipe yang tepat. Ketidak cocokan

tipe tidak akan ditunjukkan sebagai peringatan oleh compiler, tetapi langsung

ditunjukkan sebagai kesalahan yang harus diperbaiki sebelum kompilasi class tersebut

diselesaikan.

5.4.1 Type Numerik Tipe numerik berfungsi menampung bilangan. Setiap kali kita melakukan proses

matematis, kita akan menggunakan tipe ini. Ada dua jenis tipe numerik :

1. integer, yang menyimpan bilangan bulat tanpa pecahan

2. floating-point, yang menyimpan bilangan dengan bagian desimalnya.

Pada java, tidak ada kaitan antara ukuran word mesin dengan rentang nilai. Misalkan jika

menggunakan tipe int maka program Java akan selalu menggunakan 32 bit, tidak

tergantung pada platform yang digunakan. Ini mengakibatkan dalam penulisan program

akan dijamin dapat berjalan tanpa harus menyesuaikan dengan arsitektur mesin tempat

program berjalan. Adapun masalah yang terjadi jika program ternyata bergantung pada

ukuran word untuk sejumlah ketelitian numerik adalah membuat keadaan overflow atau

underflow program dapat tidak berfungsi.

93


5.4.1.1 Bilangan Bulat (Integer)

Tiadanya tipe unsigned pada Java telah mengurangi jumlah tipe data integer yaitu

menjadi hanya empat tipe, setengah dari biasanya. Tipe bilangan bulat tersebut adalah

byte, short, int dan long yang masing-masing mewakili penyimpanan 1, 2, 4, dan 8 byte.

5.4.1.1.1 byte

byte adalah tipe 8-bit bertanda. Memiliki rentang nilai -128 sampai 127. Variabel byte

dideklarasikan dengan kata kunci byte. Variabel byte digunakan jika berurusan dengan

manipulasi bit. Untuk proses perhitungan dan proses matematis kita biasanya

menggunakan integer karena tipe int lebih cocok. Berikut ini merupakan contoh dari

pendeklarasian variabel bertipe byte;

byte b; byte c = 0x55;

Untuk memberikan pemahaman tentang penggunaan tipe data byte akan diberikan source

code seperti yang ditunjukkan pada contoh 5.1 listing code di bawah ini.

Contoh 5.1 :

/* * Nama File : TipeData.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.io.*; 125 import java.util.*;

3

4 public class TipeData{ 5 public static void main(String[] args){ 6 byte a = 67;

7 byte b = 60; 8 byte c = 100;

9 byte d; 10 byte f; // akan mengakibatkan out of bound

11 byte g; 12 13 14 d = (byte)(c); 15 f = a+c; 16 g = (byte)((a+c)/2);

94


17 18 System.out.println(“Nilai a + b : “ + (a+b)); 19 System.out.println(“Nilai d : “ + d);

20 System.out.println(“Nilai (byte)(a + c) : “ + f); 21 System.out.println(“Nilai (byte)(a + c) : “ + g); 22 23 } 24 }

Dari hasil eksekusi sorce code Contoh 4.1 terlihat adanya kesalahan didalam

pendeklarasian tipe parameter. Kesalahan ini terjadi pada proses penjumlahan pada baris

15, f = a+c, dimana nilai a sama dengan 67 dan nilai c sama dengan 100, yang seharusnya

menghasilkan nilai 167, sedangkan tipe data untuk parameter f dideklarasikan bernilai

byte seperti yang dideklarasikan pada baris 10, sehingga melebihi batas nilai yang dapat

ditampung tipe data byte. Dengan mengimplementasikan source code contoh 5.1 akan

diperoleh hasil eksekusi program seperti yang ditunjukkan pada gambar 5.1.


Untuk mengatasi permasalahan ini dapat kita lakukan dengan mem-varsing hasil operasi

ke tipe data tertentu. Misalkan kita modifikasi source code contoh 5.1 yaitu dengan mem-

varsing tipe data ke byte, seperti yang ditunjukkan pada contoh 5.2 baris ke 15.

Contoh 5.2 :

/* * Nama File : TipeData.java

95




3

4 public class TipeData{ 5 public static void main(String[] args){

6 byte a = 67; 7 byte b = 60; 8 byte c = 100; 9 byte d; 10 byte f;

11 byte g; 12 13 14 d = (byte)(c); 15 f = (byte)(a+c);

16 g = (byte)((a+c)/2); 17 18 System.out.println(“Nilai a + b : “ + (a+b)); 19 System.out.println(“Nilai d : “ + d);

20 System.out.println(“Nilai (byte)(a + c) : “ + f);

21 System.out.println(“Nilai (byte)(a + c) : “ + g); 22 23 } 24 }


96


Pada baris 15 contoh 5.2 memerintahkan pada runtime java bahwa setelah operasi

penjumlahan terhadap nilai a dan c untuk mengubah tipe nilai kebentuk tipe byte. Karena

hasil operasi dimasukkan kedalam slot bit yang digunakan maka, setelah pengisian slot

yang dibutuhkan akan memberikan pengisian slot pada slot pertama dengan nilai 1. Slot

bit ini digunakan untuk memberikan tanda nilai suatu nilai bilangan. Karena nilai slot

awal diberikan dengan nilai 1, maka setelah varsing ke tipe byte nilainya menjadi negatif.

Dengan mengimplementasikan source code contoh 5.2 akan diperoleh hasil eksekusi

program seperti yang ditunjukkan pada gambar 5.2.

5.4.1.1.2 short

short adalah type 16-bit bertanda. Memiliki rentang nilai dari -32768 sampai 32767. Tipe

ini mungkin merupakan tipe yang paling jarang digunakan karena bersifat big-endian

seperti PC. Berikut ini merupakan contoh pendeklarasian tipe data short;

short s; short t = 0x55aa;

Untuk memberikan pemahaman tentang penggunaan tipe data short akan diberikan

source code seperti yang ditunjukkan pada contoh 5.2 listing code di bawah ini;

Contoh 5.3 :



3

4 public class TipeData{

5 public static void main(String[] args){ 6 short a = 32700; 7 short b = 69; 8 short c = 100; 9 short d;

10 short f; 11 short g; 12

13 d = (short)(c);

97


14 f = (short)(a+c); 15 g = (byte)((a+c)/2);

16 17 System.out.println(“Nilai a + b : “ + (a+b)); 18 System.out.println(“Nilai d : “ + d); 19 System.out.println(“Nilai (short)(a + c) : “ + f);

20 System.out.println(“Nilai (byte)((a + c)/2) : “ + g);

21 22 } 23 }

Pada contoh 5.3 baris 14 melakukan operasi penjumlahan nilai a dan c yang hasil

penjumlahannya divarsing ke tipe data short, kemudian hasil penjumlahannya

ditampilkan sesuai dengan baris 19. Pada baris 15 hasil operasi divarsing ke tipe data

byte, kemudian ditampilkan sesuai dengan baris 20. Adapun hasil hasil eksekusi program

contoh 5.3 diperoleh seperti yang ditunjukkan pada gambar 5.3.


5.4.1.1.3 int

int adalah type 32-bit bertanda. Memiliki rentang nilai dari -214783648 sampai

214783647. Tipe ini paling banyak digunakan untuk menyimpan besaran bilangan bulat

sederhana. Berikut ini merupakan contoh pendeklarasian int;

int i ; int j = 0x55aa0000;

98


Untuk memberikan pemahaman tentang penggunaan tipe data int akan diberikan source

code seperti yang ditunjukkan pada contoh 5.4 listing code di bawah ini;

Contoh 5.4 :

/* * Nama File : TipeData.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.io.*;

125 import java.util.*; 3

4 public class TipeData{ 5 public static void main(String[] args){ 6 int a = 32700; 7 int b = 0x55aa0000; 8 9 System.out.println(“Nilai a : “ + a); 10 System.out.println(“Nilai b : “ + b); 11 System.out.println(“Nilai a + b : “ + (a+b)); 12 13 } 14 }


99


Kita perhatikan bahwa pada baris 10 variabel b dideklarasikan bertipe int dengan nilai

yang diberikan dalam bentuk heksa sehingga nilai b diubah ke bentuk int . Pada baris 11

penjumlahan a dan b dilakukan setelah kedua variabel telah memiliki nilai yang bertipe

int dalam bentuk bilangan desimal. Dengan mengimplementasikan source code contoh

5.4 akan diperoleh hasil eksekusi program seperti yang ditunjukkan pada gambar 5.4.

5.4.1.1.4 long

long adalah tipe 64-bit bertanda. Rentang nilainya cukup besar, yaitu nilai dari -

9223372036854775808 sampai 9223372036854775807. Dalam beberapa kasus di mana

int tidak cukup besar untuk menampung nilai yang diinginkan, seperti operasi perkalian

dalam menghasilkan bilangan ribuan triliun, maka kita membutuhkan tipe long. Berikut

ini merupakan contoh pendeklarasian tipe data long;

long m; long n = 0x55aa000055;

Lebar tipe bilangan bulat tidak dapat dianggap sebagai besarnya ruang memori

yang akan digunakan; tipe ini lebih menunjukkan perilaku variabel dan pernyataan untuk

masing-masing tipe. Jalannya program Java bebas menggunakan ukuran berapapun untuk

variabel yang diperlukan selama tipe bersifat yang didefinisikan.

Untuk memberikan pemahaman tentang penggunaan tipe data long akan

diberikan source code seperti yang ditunjukkan pada contoh 5.5 listing code di bawah ini;

Contoh 5.5 :



3

4 public class TipeData{ 5 public static void main(String[] args){ 6 int a = 32700;

100


7 long b = 0x55aa0000; 8 9 System.out.println(“Nilai a : “ + a); 10 System.out.println(“Nilai b : “ + b); 11 System.out.println(“Nilai a + b : “ + (a+b)); 12 13 } 14 }


Pada contoh 5.5 baris 6 variabel a memiliki tipe data int, dan baris 7 variabel b memiliki

tipe data long yang akan digunakan didalam operasi penjumlahan pada baris 11. Pada

operasi penjumlahan ini kita mendefinisikan dua tipe yang berbeda. Java didalam

melakukan operasi penjumlahan akan secara langsung mengkonversi tipe data yang

paling kecil ke tipe data dengan byte yang lebih besar. Pada contoh ini, kita lihat bahwa

variabel a dideklarasikan sebagai tipda int, maka saat melakukan operasi penjumlahan

variabel a terlebih dahulu akan dikonversi ke tipe data long, sebagaimana tipe data

variabel b. Dengan mengimplementasikan source code contoh 5.5 akan diperoleh hasil

eksekusi program seperti yang ditunjukkan pada gambar 5.5.

5.4.1.2 Bilangan Pecahan (Floating Point)

Bilangan pecahan (floating point) yang lebih dikenal dengan bilangan riil,

digunakan pada fungsi perhitungan nilai yang membutuhkan ketelitian pecahan, seperti

perhitungan pada akar kuadrat, atau fungsi transenden seperti fungsi sinus, cosinus dan

101


lain sebagainya. Pada pemrograman Java ada dua macam tipe bilangan pecahan, yaitu

float dan double.

5.4.1.2.1 float

float adalah type 32-bit. Memiliki rentang nilai dari 3.4E-038 sampai 3.4E+308.

Perhitungan sederhana yang membutuhkan hanya sedikit ketelitian pecahan, misalkan

perhitungan total suatu besaran yang membutuhkan ketelitian sepersepuluh, dapat

direpresentasikan dengan tepat dengan float. Berikut ini merupakan contoh

pendeklarasian tipe data float;

float f; float f2 = 3.14f;

5.4.1.2.3 double

double adalah tipe 64-bit. Memiliki rentang nilai dari 1.7E-308 sampai 1.7E+308. Jika

ingin menjaga ketelitian sampai banyak perulangan, atau mengolah bilangan besar,

double adalah pilihan terbaik. Berikut ini merupakan contoh pendeklarasian tipe data

double;

double d; double pi = 3.14159365358979323846;

5.4.2 Casting Ada beberapa keadaan dimana kita mendapatkan suatu besaran, dan ingin

menyimpan besaran tersebut pada variabel dengan tipe berbeda. Beberapa tipe

memungkinkan untuk disimpan begitu saja tanpa penggunaan cast; yang disebut konversi

tipe otomatis seperti yang diberikan pada contoh 5.5. Pada Java konversi otomatis hanya

mungkin jika compiler mengetahui variabel tujuan memiliki presisi yang cukup untuk

menampung nilai sumber. Misalkan menyimpan variabel byte pada variabel int. Ini

disebut pelebaran (widening) dan promosi (promotion), karena tipe yang lebih kecil

dilebarkan atau dinaikkan menjadi tipe yang lebih besar. Tipe int selalu cukup untuk

menampung besarnya byte, jadi tidak diperlukan cast secara eksplisit. Tetapi

kebalikannya tidak selalu berlaku, jika kita ingin memindahkan besaran int ke dalam

variabel byte, cast harus dinyatakan secara eksplisit pada variabel int. Ini disebut

penyempitan (narrowing), karena kita memang membuat besaran ditulis lebih pendek

102


sehingga dapat disimpan di tempat yang baru. Kita melakukan cast pada suatu besaran

dengan memberi tipe dalam kurung di depannya. Berikut ini merupakan contoh cast tipe

data int ke tipe data byte ;

int a = 100; byte b = (byte) a;

Untuk menghindari overflow maka runtime java akan melakukan casting otomatis

terhadap variabel, misalkan jika variabel byte, short, dan int digunakan dalam pernyataan

maka hasilnya akan selalu dinaikkan menjadi int. Jika sebuah long digunakan dalam

pernyataan, seluruh pernyataan dinaikkan menjadi long. Ingat bahwa semua besaran

integer literal akan dianggap int kecuali jika ditambahkan huruf ‘L’ dibelakangnya.

5.4.3 Karakter Karena Java menggunakan unicode untuk merepresentasikan karakter pada string,

maka tipe char menjadi 16-bit tidak bertanda dan digunakan untuk menyimpan puluhan

ribu karakter dari kumpulan karakter unicode internasional. Rentang nilai char ini adalah

0 sampai 65535. Berikut ini merupakan contoh pendeklarasian tipe data char;

char c; char c2 =’a’;

Meskipun char tidak digunakan sebagai integer, kita dapat mengoperasikannya

sebagai integer. Ini memungkinkan kita untuk menambahkan dua karakter bersama

karakter, atau meningkatkan nilai variabel karakter. Contoh

int a = 4; char b = ‘2’; char c = (char) (a +b);

variabel c akhirnya berisi karakter ‘6’.

5.4.4 Boolean Java memiliki tipe data sederhana untuk besaran logika, yang disebut boolean.

Tipe ini hanya dapat memiliki dua kemungkinan nilai, true dan false. Boolean

merupakan tipe yang dibutuhkan oleh semua operator pengaturan alur bersyarat seperti if,

while, dan do. Berikut ini merupakan contoh pendeklarasian variabel bertipe boolean;

boolean done = false;

103


5.5 Tipe Data Bentukan

Tipe data bentukan adalah tipe data yang diperoleh berdasarkan kumpulan tipe

data – tipe data dasar dengan tujuan tertentu. Tipe data bentukan diperlukan karena tidak

semua atribut dari suatu objek hanya menggunakan tipe data dasar. Misalkan Objek

manusia memiliki atribut tanggal lahir, misalkan 26-09-1978. Tanggal lahir yang hendak

disimpan ini merupakan penggabungan dari tiga buah tipe dasar int. Pembentukan tipe

data bentukan dilakukan dengan cara mendefisikan class yang mengandung pengesetan

dan pengambilan nilai-nilai atribut yang dimilikinya.

Bentuk umum pembentukan tipe data bentukan adalah sebagai berikut :

public class namaClass{ // deklarasi tipeDataDasar atribut; // konstruktor // method set // method get }

Untuk memberikan pemahaman yang lebih jelas, akan diberikan contoh

pembenrukan tipe data dasar beserta penggunaanya, seperti yang diberikan pada Contoh

5.6 dan Contoh 5.7.

Contoh 5.6 :

/* * Nama File : Barang.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class Barang { 2 3 private String kodeBarang ; 4 private String namaBarang ; 5 private double hargaSatuan ; 6 private int jumlah ; 7 8 9 public Barang() { 10 super(); 11 // TODO Auto-generated constructor stub 12 }

104


13 14 public Barang(String kodeBarang, String namaBarang, double 15 hargaSatuan, int jumlah) { 16 super(); 17 this. kodeBarang = kodeBarang; 18 this. namaBarang = namaBarang; 19 this. hargaSatuan = hargaSatuan; 20 this. jumlah = jumlah; 21 } 22 23 public String getKodeBarang() { 24 return kodeBarang ; 25 } 26 public void setKodeBarang(String kodeBarang) { 27 this. kodeBarang = kodeBarang; 28 } 29 public String getNamaBarang() { 30 return namaBarang ; 31 } 32 public void setNamaBarang(String namaBarang) { 33 this. namaBarang = namaBarang; 34 } 35 public double getHargaSatuan() { 36 return hargaSatuan ; 37 } 38 public void setHargaSatuan( double hargaSatuan) { 39 this. hargaSatuan = hargaSatuan; 40 } 41 public int getJumlah() { 42 return jumlah ; 43 } 44 public void setJumlah( int jumlah) { 45 this. jumlah = jumlah; 46 } 47 48 public String toString(){ 49 return getKodeBarang() + “ : “ + getNamaBarang() + “ : “ + 50 getHargaSatuan() + “ : “ + getJumlah(); 51 52 } 53 }

Contoh 5.7 :

/* * Nama File : Pelanggan.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

125 public class Pelanggan { 2 3 private String kodePelanggan ; 4 private String namaPelanggan ;

105


5 private String alamat ; 6 private String noHP; 7 private Barang beliBarang; 8 9 10 public Pelanggan() { 11 super(); 12 // TODO Auto-generated constructor stub 13 } 14 15 public Pelanggan(String kodePelanggan, String namaPelangg an, 16 String alamat,String noHP) { 17 super(); 18 this. kodePelanggan = kodePelanggan; 19 this. namaPelanggan = namaPelanggan; 20 this. alamat = alamat; 21 this. noHP = noHP; 22 } 23 24 25 public String getKodePelanggan() { 26 return kodePelanggan ; 27 } 28 29 30 public void setKodePelanggan(String kodePelanggan) { 31 this. kodePelanggan = kodePelanggan; 32 } 33 34 35 public String getNamaPelanggan() { 36 return namaPelanggan ; 37 } 38 39 public void setNamaPelanggan(String namaPelanggan) { 40 this. namaPelanggan = namaPelanggan; 41 } 42 43 public String getAlamat() { 44 return alamat ; 45 } 46 47 public void setAlamat(String alamat) { 48 this. alamat = alamat; 49 } 50 public String getNoHP() { 51 return noHP; 52 } 53 public void setNoHP(String noHP) { 54 this. noHP = noHP; 55 } 56 public Barang getBeliBarang() { 57 return beliBarang; 58 } 59 public void setBeliBarang(Barang beliBarang) { 60 this.beliBarang = beliBarang; 61 }

106


62 public String toString(){ 63 return getKodePelanggan() + “ : “ + getNamaPelanggan() + “ 64 “ + getAlamat() + “ : “ + getNoHP(); 65 } 66 }

Contoh 5.8 :

/* * Nama File : DriverPembeliBarang.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import javax.swing.JoptionPane; 2 3 4 public class DriverPembeliBarang { 5 public static void main(String[] args) { 6 // TODO Auto-generated method stub 7 Pelanggan pel = new Pelanggan(); 8 // proses pemberian nilai atribut khusus objek pel 9 // dengan memanggil method setDataPelanggan 10 pel = setDataPelanggan(); 11 12 // proses mengambil informasi pelanggan 13 String infoPel = pel.toString(); 14 // mengambil info barang yg dibeli pelanggan 15 // ambil terlebih dahulu barang yg dibeli pelanggan pel 16 Barang pelBeli = pel.getBeliBarang(); 17 String infoBarang = pelBeli.toString(); 18 String info = “Informasi Data Pelanggan :\n” + infoPel + 19 “\n” + “Informasi Barang yang dibeli :\n” + 20 infoBarang; 21 // dengan menggunakan JoptionPane 22 JoptionPane.showMessageDialog(null, info); 23 23 } 25 26 public static Pelanggan setDataPelanggan(){ 27 Pelanggan pel = new Pelanggan(); 28 String kode, nama, alamat, hp; 29 Barang myBarang; 30 31 kode = JoptionPane. showInputDialog( null, ”Masukkan kode 32 Pelanggan” ); 33 nama = JoptionPane. showInputDialog( null, “Masukkan nama 34 Pelanggan” ); 35 alamat = JoptionPane. showInputDialog( null, “Masukkan alamat 36 Pelanggan” ); 37 hp = JoptionPane. showInputDialog( null, “Masukkan no Hp 38 Pelanggan” ); 39 pel.setKodePelanggan(kode); 40 pel.setNamaPelanggan(nama); 41 pel.setAlamat(alamat);

107


42 pel.setNoHP(hp); 43 44 myBarang = setDataBarang(); 45 pel.setBeliBarang(myBarang); 46 return pel; 47 } 48 49 public static Barang setDataBarang(){ 50 Barang brg = new Barang(); 51 String kodeBarang; 52 String namaBarang; 53 double hargaSatuan; 54 int jumlah; 55 56 kodeBarang = JoptionPane. showInputDialog( null, “Masukkan 57 kode Barang” ); 58 namaBarang = JoptionPane. showInputDialog( null, “Masukkan 59 nama Barang” ); 60 hargaSatuan =Double. parseDouble(JoptionPane. 61 showInputDialog( null, ”Masukkan harga satuan 62 Barang” )); 63 jumlah = Integer. parseInt(JoptionPane. showInputDialog( null, 64 “Masukkan jumlah Barang” )); 65 66 brg.setKodeBarang(kodeBarang); 67 brg.setNamaBarang(namaBarang); 68 brg.setHargaSatuan(hargaSatuan); 69 brg.setJumlah(jumlah); 70 return brg; 71 } 72 73 }

Gambar 5.6. Hasil eksekusi program contoh 5.7 untuk input kode Pelanggan dan kode Barang

Gambar 5.7 Hasil eksekusi program contoh 5.7 dalam menampilkan informasi

108


Pada contoh 5.6 kita membentuk suatu tipe data bentukan Barang yang akan digunakan

pada Class Pelanggan. Pada Contoh 5.7 baris 7 variabel beliBarang memiliki tipe data

Barang yang kita bentuk dari Clas Barang pada Contoh 5.6, dan baris 56 sampai baris 61

kita melakukan proses memberikan nilai beliBarang dan pengambilan nilai variabel

nilaiBarang yang akan digunakan didalam Contoh 5.8. Pada Contoh 5.8, baris 1 kita

meng-import JoptionPane, yang digunakan untuk proses input dari pengguna dan output

ke pengguna. Pada baris 7 Contoh 5.8 kita membentuk objek pel dari class Pelanggan,

yang nilai atribut khusus dari objek pel didapatkan dengan menggunakan method

setDataPelanggan( ) yang terdapat pada baris 26. Pada baris 44 pada method

setDataPelanggan( ) menggunakan method setDataBarang( ) yang terdapat pada baris

49. Karena setDataBarang( ) mengembalikan nilai tipe data bentukan Barang, maka

pembentukan methodnya adalah public static Barang setDataBarang(). Agar

method ini dapat berjalan dengan baik, maka kita harus mengembalikan suatu nilai

dengan tipe data bentukan Barang, seperti yang diberikan pada baris 70. Hal yang sama

juga berlaku untuk method setDataPelanggan( ). Pada baris ke 13 kita mengambil

informasi pelanggan dengan menggunakan method toString( ) yang dimiliki oleh Class

Pelanggan dan untuk mengambil informasi data Barang yang telah dibeli oleh

pelanggan pel, kita menggunakan method getBeliBarang()dari objek pel seperti yang

ditunjukkan pada baris 16. Untuk menampilkan informasi kepada pengguna kita

menggunakan JoptionPane, showMessageDialog( ), seperti yang ditunjukkan pada baris

22. Adapun hasil eksekusi program dari Contoh 5.8 adalah seperti yang ditunjukkan pada

gambar 5.6 untuk proses input, dan gambar 5.7 untuk proses output dalam menampilkan

informasi nilai khusus yang dimiliki oleh objek pel.

5.6 Array

Pada pendeklarasian variabel, sering kali kita menggunakan sebuah tipe data

beserta nama variabel atau indentifier yang unik, dimana untuk menggunakan variabel

tersebut kita akan memanggil dengan nama identifier-nya. Misalkan kita memiliki empat

buah identifier yang berbeda untuk setiap variabel, seperti berikut ini :

int bilangan1 = 1; int bilangan2 = 2;

109


int bilangan3 = 3; int bilangan4 = 4;

Untuk menginisialisasi dan menggunakan variabel pada saat variabel-variabel tersebut

digunakan untuk tujuan yang sama cukup direpotkan. Kita harus menentukan cukup

banyak variabel yang harus dideklarasikan. Pada java memiliki kemampuan untuk

menggunakan satu variabel yang dapat menyimpan sebuah data list dan kemudian

memanipulasinya dengan lebih efektif. Tipe variabel ini dikenal dengan istilah Array.

Array adalah kelompok variabel dengan tipe sejenis dan dinyatakan dengan nama

yang sama. Array adalah tipe khusus yang menyatukan sekelompok variabel dengan tipe

yang sama. Sekelompok variabel dangan tipe yang sama maksudnya adalah bahwa pada

suatu variabel tertentu hanya dapat menyimpan tipe data yang sama. Misalkan jika kita

hendak menyimpan nilai-nilai tipe int pada variabel bilangan maka kita dapat

mendeklarasikannya pada suatu array, tetapi kita tidak dapat memasukkan nilai lain ke

dalam variabel bilangan tersebut. Ini menunjukkan bahwa saat kita hendak memasukkan

nilai di luar tipe int, akan mengakibatkan suatu kesalahan.

Pendeklarasian Array

Array harus dideklarasikan seperti halnya sebagai sebuah variabel. Pendeklarasian

array pada java dapat dilakukan dengan cara, penentuan tipe data diikuti buka kurung dan

tutup kurung, diikuti oleh nama identifier. Berikut ini merupakan contoh pendeklarasian

array tipe int, dengan identifier bulan;

int bulan [ ];

atau dapat juga kita deklarasikan dengan cara

int [ ] bulan;

untuk mengisi nilai-nilai array dilakukan dengan operator khusus new, untuk

mengalokasikan ruang untuk array. Untuk menggunakan operator new, kita harus

menyediakan tipe dan bilangan integer positif untuk menyatakan alokasinya. Berikut ini

merupakan contoh mengalokasikan 12 integer dalam array yang berkaitan dengan

variabel bulan yang telah dideklarasikan sebagai int.

Bulan = new int[12];

110


Selain menggunakan sebuah keyword baru untuk meng-instansiasi array, dapat juga

dilakukan dengan cara mendeklarasikan array secara otomatis, seperti yang ditunjukkan

berikut ini;

String[ ] hariHari = {“Senin”, “Selasa”, “Rabu”, “Kamis”, “Jumat”, “Sabtu”, “Mingg”};

Pendeklarasian array dengan identifier hariHari, menyatakan bahwa hariHari

dialokasikan sebanyak 7 alokasi dengan tipe data String.

Pengaksesan Elemen Array

Untuk mengakses sebuah elemen dalam array atau mengakses sebagian dari array

dilakukan dengan pengaksesan berdasarkan nomor index atau subscript array. Setiap

elemen array memiliki sebuah nomor index atau subscript. Index pada array selalu

bertipe data integer. Index array dimulai dari nol (0), kemudian akan terus bertambah

sampai list value dari array tersebut berakhir. Karena index array dimulai dari 0, maka

jika index terbesar dari suatu array adalah panjang array dikurangi dengan satu. Sebagai

contoh pada array hariHari yang telah kita deklarasikan diatas akan kita peroleh :

// ini akan memberikan informasi Sekarang hari : Senin System.out.println(“Sekarang hari : ”hariHari[0]); // untuk memberikan nilai pada elemen ke 2 adalah Selasa hariHari[1] = “Selasa”;

Untuk memberikan pemahaman yang lebih jelas tentang penggunaan array satu dimensi,

kita akan perhatikan contoh 5.9 yang diberikan.

Contoh 5.9 :

1 /** File Name : ArraySatuDimensi.java 2 * Create by : Jasman Pardede

125 * Create date: 4 * Description: 5 */ 6

7 import java.io.*; 8 import java.util.*; 9 10 public class ArraySatuDimensi{ 11 public static int A[] = new int[10];

12 13 public static void main(String[] args){

111


14 String cmd; 15 int x;

16 boolean KELUAR = false; 17 18 BufferedReader inputUser = new BufferedReader(new 19 InputStreamReader(System.in)); 20 21 22 System.out.println(“Masukkan 10 buah bilangan”); 23 24 /* Input 10 buah bilangan */ 25 for(int i=0; i<10; i++){ 26 System.out.print(“Bilangan ke – “ + (i+1) + “ : “ );

27 try{ 28 cmd = inputUser.readLine(); 29 x = Integer.parseInt(cmd); 30 A[i] = x; 31 System.out.println(“”);

32 }catch(IOException e){ 33 return; 34 }catch(NumberFormatException e){ 35 System.out.println(“Anda memasukkan data di luar format”); 36 } 37 38 } 39 40 /* Cetak bilangan yang diinginkan */ 41 while(!KELUAR){ 42 System.out.println(“No bilangan yang ingin ditampilkan keluar 0 : “);

43 try{ 44 cmd = inputUser.readLine(); 45 x = Integer.parseInt(cmd); 46 if(x==0) 47 break; 48 System.out.println(“Bilangan ke : “ + x + “ adalah “ + A[x-1]); 49 }catch(IOException e){ 50 return;

51 }catch(NumberFormatException e){ 52 System.out.println(“Anda memasukkan data di luar format”); 53 } 54 55 } 56 } 57 58 }

Pada baris 11 kita telah mendeklarasikan variabel A array satu dimensi, dengan

jumlah elemen array 10. Pada baris 25 akan dilakukan pengulangan sebanyak 10 kali

dengan menggunakan pengulangan for yang akan dibahas pada bab 5. Pada baris 26

112


runtime Java meminta input dari keyboard, setalah menampilkan perintah “Bilangan ke –

i”. Masukan dari keyboard ditangkan variabel cmd dengan string sesuai dengan

pendeklarasian varaibel pada baris 14 sesuai dengan perintah yang dilakukan pada baris

28. Pada baris 29 masukan string akan dikonversi ke tipe data int, kemudian akan

dimasukkan kedalam array A yang telah kita definisikan. Operasi ini dilakukan sebanyak

sepuluh kali.


Pada baris 41 menyatakan bahwa program akan tetap dieksekusi selama nilai

KELUAR bernilai true, yang dalam hal ini akan selalu true jika tidak di break, yaitu jika

kita tidak memasukkan nilai nol untuk mengekseksi baris 47 atau jika kita memasukkan

format data yang salah atau diluar batasan nilai array A. Sedangkan jika nilai yang kita

berikan antara 1 samapi 10 maka akan menampilkan nilai array A yang telah disimpan.

Misalkan jika kita memberikan nilai 2 untuk ditampilkan maka array A akan memberikan

nilai A pada indeks ke-2. Dengan mengimplementasikan source code contoh 5.9 akan

diperoleh hasil eksekusi program seperti yang ditunjukkan pada gambar 5.8.

113


Array Elemen Tipe Data Bentukan

Misalkan kita hendak menyimpan informasi tentang seorang pembeli dapat

membeli beberapa barang. Maka untuk menyimpan kumpulan data atau list barang yang

dibeli oleh pembeli dapat dilakukan dengan menggunakan array dengan tipe data

bentukan Barang. Pendeklarasian array dengan tipe data bentukan pada dasarnya sama

dengan pendeklarasian array dengan tipe data dasar, yaitu : <<Tipe data bentukan>>[ ]

namaIdentifier . Misalkan kita hendak menyimpan 10 barang maka dapat dideklarasikan

dengan cara :

Barang[] arrBarang = new Barang[10];

Untuk memberikan pemahaman yang lebih jelas tentang penggunakan array dengan tipe

data bentukan akan diberikan contoh dengan studi kasus berikut ini.

Studi kasus :

Pada suatu toko hendak mendaftarkan data semua pelanggan yang membeli barang

beserta barang-barang yang dibelinya, seperti yang ditunjukkan dibawah ini.

Kode Pelanggan : PL-001

Nama Pelanggan : Jajang

Alamat : Jln. Dago Atas No.23

No. HP : 081322089387

No Kode Barang Nama Barang Harga Satuan Jumlah Harga Total

1 BK-001 Hello Kitty 5000 10 50000 2 PL-001 Snowman 4500 12 54000 3 BK-002 Mirage 20000 60 1200000

Jumlah 82 1304000


Nama Pelanggan : Jojon Bandoro

Alamat : Jln. Dago Tea Haouse No.13

No. HP : 08132208982911


1 BK-001 Hello Kitty 5000 2 10000 2 PL-001 Snowman 4500 4 18000 3 BK-002 Mirage 20000 12 240000

Jumlah 18 268000

114



Nama Pelanggan : Miranda Gultom

Alamat : Jln. PHK. Mustofa No.23

No. HP : 08132208983911


1 BK-001 Hello Kitty 5000 6 30000 2 PL-002 Pilot 3000 4 12000 3 PL-003 Standard 3500 62 217000

Jumlah 72 259000

Buatlah aplikasi Java sederhana di dalam memfasilitasi permintaan pengguna didalam :

1. Menentukan harga barang termahal.

2. Menentukan jumlah total yang harus dibayar setiap pelanggan.

3. Menentukan pelanggan yang melakukan transaksi pembelian terbesar.

Solusi Penyelesain Studi Kasus :

Untuk memfasilitasi kebutuhan pengguna yang berhubungan dengan proses

pengembangan perangkat lunak, terlebih dahulu kita memperhatikan objek-objek yang

terlibat. Berdasarkan objek yang terlibat akan kita bentuk ke dalam class diagram, seperti

yang dinyatakan pada bab 3.

Gambar 5.9 Class diagram studi kasus

115


Untuk menentukan objek-objek yang terlibat terlebih dahulu kita harus dapat

menentukan objek yang paling dasar. Pada kasus di atas, pembeli membeli barang, ini

berarti bahwa pada suatu objek pembeli akan mengandung list data Barang yang akan

dibelinya. Jadi Objek yang paling dasar tentunya adalah objek barang, kemudian objek

pembeli. Untuk memfasilitasi kebutuhan pengguna untuk menjawab ke tiga permasalahan

di atas tentu kita memerlukan objek khusus. Untuk penanganan proses yang berhubungan

dengan Barang seperti menentukan harga barang termurah, total barang yang dibeli, kita

bentuk objek barangBean. Untuk penangan proses yang berhubungan dengan Pelanggan,

seperti menentukan pelanggan yang melakukan transaksi pembelian terbesar kita

membentuk objek pelangganBean. Sehingga akan kita dapatkan class diagram seperti

yang dinyatakan pada gambar 5.9.

Berdasarkan class diagram yang diperoleh pada gambar 5.9, maka akan

diimplementasikan ke dalam listing code java seperti yang dinyatakan pada Contoh 5.10,

Contoh 5.11, dan Contoh 5.12. Dengan class Barang seperti yang dinyatakan pada

Contoh 5.7.

Contoh 5.10 :

/* * Nama File : Pelanggan.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

125 public class Pelanggan { 2 3 private String kodePelanggan ; 4 private String namaPelanggan ; 5 private String alamat ; 6 private String noHP; 7 private Barang[] arrBarang; 8 private Barang beliBarang ; 9 10 public Pelanggan() { 11 super(); 12 // TODO Auto-generated constructor stub 13 } 14 15 public void setBanyaknyaBarang( int mySize){ 16 arrBarang = new Barang[mySize]; 17 } 18

116


19 public Pelanggan(String kodePelanggan, String namaPelangg an, 20 String alamat, String noHP) { 21 super(); 22 this. kodePelanggan = kodePelanggan; 23 this. namaPelanggan = namaPelanggan; 24 this. alamat = alamat; 25 this. noHP = noHP; 26 } 27 public String getKodePelanggan() { 28 return kodePelanggan ; 29 } 30 31 public void setKodePelanggan(String kodePelanggan) { 32 this. kodePelanggan = kodePelanggan; 33 } 34 public String getNamaPelanggan() { 35 return namaPelanggan ; 36 } 37 public void setNamaPelanggan(String namaPelanggan) { 38 this. namaPelanggan = namaPelanggan; 39 } 40 public String getAlamat() { 41 return alamat ; 42 } 43 public void setAlamat(String alamat) { 44 this. alamat = alamat; 45 } 46 public String getNoHP() { 47 return noHP; 48 } 49 public void setNoHP(String noHP) { 50 this. noHP = noHP; 51 } 52 public Barang[] getArrBarang() { 53 return arrBarang; 54 } 55 public void setArrBarang(Barang[] arrBarang) { 56 this.arrBarang = arrBarang; 57 } 58 public Barang getBeliBarang() { 59 return beliBarang ; 60 } 61 public void setBeliBarang(Barang beliBarang) { 62 this. beliBarang = beliBarang; 63 } 64 public String toString(){ 65 return getKodePelanggan() + “ : “ + getNamaPelanggan() + “ 66 : “ + getAlamat() + “ : “ + getNoHP(); 67 } 68 }

Contoh 5.11 :

/* * Nama File : BarangBean.java

117



1 public class BarangBean { 2 3 public BarangBean() { 4 super(); 5 // TODO Auto-generated constructor stub 6 } 7 // menghitung harga total barang 8 // berdasarkan harga satuan di kali dengan jumlah b arang 9 public double hargaTotal(Barang myBrg){ 10 return myBrg.getHargaSatuan() * myBrg.getJumlah(); 11 } 12 13 public int jumlahTotal(Barang[] arrBarang){ 14 int sum = 0; 15 Barang brg = new Barang(); 16 17 for( int i=0; i< arrBarang. length ; i++){ 18 brg = arrBarang[i]; 19 sum += brg.getJumlah(); 20 } 21 return sum; 22 } 23 24 // menghitung tumlah total transaksi yang dimiliki oleh pelanggan 25 public double hargaTotalTransaksi(Barang[] arrBarang){ 26 int sumTrans = 0; 27 Barang brg = new Barang(); 28 29 for( int i=0; i< arrBarang. length ; i++){ 30 brg = arrBarang[i]; 31 sumTrans += brg.getJumlah()* brg.getHargaSatua n(); 32 } 33 return sumTrans; 34 } 35 36 // menentukan barang termurah dari setiap barang pe langgan 37 public Barang hargaBarangTermurah(Barang[] arrBarang){ 38 Barang brgMin = new Barang(); 39 int indexBrg; 40 Barang brg; 41 double hargaBrg; 42 brgMin = arrBarang[0]; 43 indexBrg = 0; 44 45 double hrgMin = brgMin.getHargaSatuan(); 46 47 for( int i=1; i< arrBarang. length ; i++){ 48 brg = arrBarang[i]; 49 hargaBrg = brg.getHargaSatuan(); 50

118


51 if(hargaBrg<hrgMin){ 52 indexBrg = i; 53 } 54 } 55 return arrBarang[indexBrg]; 56 } 57 58 // menentukan barang termahal dari setiap barang pe langgan 59 public Barang hargaBarangTermahal(Barang[] arrBarang){ 60 Barang brgMin = new Barang(); 61 int indexBrg; 62 Barang brg; 63 double hargaBrg; 64 brgMin = arrBarang[0]; 65 indexBrg = 0; 66 67 double hrgMin = brgMin.getHargaSatuan(); 68 69 for( int i=1; i< arrBarang. length ; i++){ 70 brg = arrBarang[i]; 71 hargaBrg = brg.getHargaSatuan(); 72 73 if(hargaBrg>hrgMin){ 74 indexBrg = i; 75 } 76 } 77 return arrBarang[indexBrg]; 78 } 79 }

Contoh 5.12 :

/* * Nama File : PelangganBean.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

125 public class PelangganBean { 2 3 public PelangganBean() { 4 super(); 5 // TODO Auto-generated constructor stub 6 } 7 8 // mengambil total transaksi termahal 9 public double getTransaksiTerbesar(Pelanggan[] arrPelanggan){ 10 double transMax = 0.0; 11 double totalTransaksi; 12 BarangBean brgBean = new BarangBean(); 13 14 Pelanggan pel = new Pelanggan(); 15 pel = arrPelanggan[0]; 16 Barang[] arrBarangPel = pel.getArrBarang();

119


17 transMax = brgBean.hargaTotalTransaksi(arrBaran gPel); 18 19 for( int i=1; i<arrPelanggan. length ; i++){ 20 pel = arrPelanggan[i]; 21 arrBarangPel = pel.getArrBarang(); 22 totalTransaksi = brgBean.hargaTotalTransaksi( 23 arrBarangPel); 24 if(totalTransaksi > transMax) 25 transMax = totalTransaksi; 26 } 27 return transMax; 28 } 29 30 // menentukan pelanggan yang melakukan transaksi te rbesar 31 public Pelanggan getPelangganTransaksiTerbesar(Pelanggan[] 32 arrPelanggan){ 33 double transMax = 0.0; 34 double totalTransaksi; 35 int indexPel; 36 BarangBean brgBean = new BarangBean(); 37 38 Pelanggan pel = new Pelanggan(); 39 pel = arrPelanggan[0]; 40 indexPel = 0; 41 Barang[] arrBarangPel = pel.getArrBarang(); 42 transMax = brgBean.hargaTotalTransaksi(arrBaran gPel); 43 44 for( int i=1; i<arrPelanggan. length ; i++){ 45 pel = arrPelanggan[i]; 46 arrBarangPel = pel.getArrBarang(); 47 totalTransaksi = brgBean.hargaTotalTransaksi 48 (arrBarangPel); 49 if(totalTransaksi > transMax){ 50 transMax = totalTransaksi; 51 indexPel = i; 52 } 53 } 54 return arrPelanggan[indexPel]; 55 } 56 57 // menampilkan informasi barang termahal 58 public void displayBarangTermahal(Pelanggan[] arrPelanggan){ 59 Pelanggan pel = new Pelanggan(); 60 BarangBean brgBean = new BarangBean(); 61 Barang[] arrBarangPel; 62 Barang brg = new Barang(); 63 64 for( int i=1; i<arrPelanggan. length ; i++){ 65 pel = arrPelanggan[i]; 66 arrBarangPel = pel.getArrBarang(); 67 brg = brgBean.hargaBarangTermahal(arrBarangPe l); 68 } 69 System. out.println(brg.toString()); 70 } 71 }

120


Contoh 5.12 :

/* * Nama File : DriverPembelianBarang.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

125 import javax.swing.JoptionPane; 2

125 public class DriverPembelianBarang { 4 5 public static Pelanggan[] arrPel; 6 7 public static void main(String[] args) { 8 // TODO Auto-generated method stub 9 int jlhPel; 10 PelangganBean pb = new PelangganBean(); 11 12 jlhPel = Integer. parseInt(JoptionPane. showInputDialog( null, 13 “Masukkan banyaknya Pelanggan” )); 14 setJumlahPelanggan(jlhPel); 15 16 for( int i=0; i< arrPel. length ; i++){ 17 arrPel[i] = setDataPelanggan(); 18 } 19 displayPelanggan( arrPel); 20 pb.displayBarangTermahal( arrPel); 21 pb.getPelangganTransaksiTerbesar( arrPel); 22 } 23 24 public static void setJumlahPelanggan( int size){ 25 arrPel = new Pelanggan[size]; 26 } 27 28 29 public static Pelanggan setDataPelanggan(){ 30 Pelanggan pel = new Pelanggan(); 31 String kode, nama, alamat, hp; 32 int jlhBarang; 33 Barang[] arrBarang; 34 35 kode = JoptionPane. showInputDialog( null, “Masukkan kode 36 Pelanggan” ); 37 nama = JoptionPane. showInputDialog( null, “Masukkan nama 38 Pelanggan” ); 39 alamat = JoptionPane. showInputDialog( null, “Masukkan alamat 40 Pelanggan” ); 41 hp = JoptionPane. showInputDialog( null, “Masukkan no Hp 42 Pelanggan” ); 43 pel.setKodePelanggan(kode); 44 pel.setNamaPelanggan(nama); 45 pel.setAlamat(alamat); 46 pel.setNoHP(hp);

121


47 48 jlhBarang = Integer. parseInt(JoptionPane. 49 showInputDialog( null, “Masukkan jumlah 50 barang Pelanggan” )); 51 arrBarang = new Barang[jlhBarang]; 52 53 for( int i=0; i<jlhBarang;i++){ 54 arrBarang[i] = setDataBarang(); 55 } 56 pel.setArrBarang(arrBarang); 57 return pel; 58 } 59 60 public static Barang setDataBarang(){ 61 Barang brg = new Barang(); 62 String kodeBarang; 63 String namaBarang; 64 double hargaSatuan; 65 int jumlah; 66 67 kodeBarang = JoptionPane. showInputDialog( null, “Masukkan 68 kode Barang” ); 69 namaBarang = JoptionPane. showInputDialog( null, “Masukkan 70 nama Barang” ); 71 hargaSatuan = Double. parseDouble(JoptionPane. 72 showInputDialog( null, “Masukkan harga satuan 73 Barang” )); 74 jumlah = Integer. parseInt(JoptionPane. showInputDialog( null, 75 “Masukkan jumlah Barang” )); 76 77 brg.setKodeBarang(kodeBarang); 78 brg.setNamaBarang(namaBarang); 79 brg.setHargaSatuan(hargaSatuan); 80 brg.setJumlah(jumlah); 81 return brg; 82 } 83 84 // menampilkan informasi barang 85 public void displayBarang(Barang[] arrBarang){ 86 Barang brg = new Barang(); 87 BarangBean bb = new BarangBean(); 88 89 System. out.println( “====================================” ); 90 for( int i=0; i< arrBarang. length ; i++){ 91 brg = arrBarang[i]; 92 System. out.println(brg.getKodeBarang() + “\t\t : “ + 93 brg.getNamaBarang() + “\t\t : “ + 94 brg.getHargaSatuan() + “\t\t : “ + brg.getJumlah() + 95 “\t\t: “ + bb.hargaTotal(brg)); 96 } 97 System. out.println( “====================================” ); 98 } 99 100 public static void displayPelanggan(Pelanggan[] arrPelanggan){ 101 Pelanggan pel = new Pelanggan(); 102 BarangBean brgBean = new BarangBean(); 103

122


104 for( int i=0; i<arrPelanggan. length ; i++){ 105 pel = arrPelanggan[i]; 106 Barang[] arrBarangPel = pel.getArrBarang(); 107 System. out.println( “Kode Pelanggan : “ + 108 pel.getKodePelanggan()); 109 System. out.println( “Nama Pelanggan : “ + 110 pel.getNamaPelanggan()); 111 System. out.println( “Alamat Pelanggan : “ + 112 pel.getAlamat()); 113 System. out.println( “No. HP Pelanggan : “ + 114 pel.getNoHP()); 115 // prose menampilkan barang-barang yg dibeli 116 Barang[] arrBrgBeli = pel.getArrBarang(); 117 displayBarang(arrBrgBeli); 118 System. out.println( ===============================” ); 119 System. out.println( “ Total transaksi : “ + 120 brgBean.jumlahTotal(arrBarangPel) + ” : “ + 121 brgBean.hargaTotalTransaksi(arrBarangPel)); 122 System. out.println( ===============================” ); 123 } 124 } 125 }

Pada contoh 5.6 kita membentuk suatu tipe data bentukan Barang yang akan

digunakan pada Class Pelanggan dan contoh 5.10 kita membentuk tipe data bentukan

Pelanggan. Pada class Pelanggan baris ke 7 kita membentuk list arrBarang dengan tipe

bentukan Barang, yang akan diberikan alokasi list sesuai dengan permintaan pengguna

saat aplikasi dijalankan seperti yang dinanyakatan pada baris 16. Pada baris 55 kita

memberikan atau men-set nilai arrBarang dengan list barang yang diberikan oleh

pengguna. Pada baris ke 52 kita mengambil list barang yang dimiliki oleh objek pelangan

dengan tipe data yang dikembalikan adalah list tipe data bentukan barang, yaitu public

Barang[] getArrBarang(). Pada Contoh 5.11 baris 9 digunakan untuk menentukan

harga total suatu jenis barang, baris 13 digunakan untuk mengitung jumlah total barang

yang dibeli oleh seorang pelanggan. Baris 25 digunakan untuk menentukan jumlah total

transaksi yang harus dibayar oleh seorang pelanggan. Pada baris 37 digunakan untuk

menentukan barang dengan harga termurah dengan tipe data yang dikembalikan adalah

Barang seperti yang dinyatakan pada baris 55. Dengan cara yang sama untuk

menentukan barang dengan harga barang termahal yang dibeli oleh pembeli dinyatakan

pada baris 57.

Pada Contoh 5.12 digunakan untuk melakukan fungsi-fungsi yang berhubungan

dengan operasional Pelanggan. Pada baris 9 digunakan untuk menentukan nilai total

123


transaksi terbesar dari semua pelanggan, disini dimaksudkan dari setiap total transaksi

yang dilakukan oleh pelanggan akan diambil nilai total transaksi yang tersebesar dan nilai

total transaksinyalah yang akan ditampilkan. Jika menggunakan data contoh kasus maka

besaran nilai yang dikembalikan adalah 1304000. Untuk mendapatkan objek pelanggan

yang melakukan transaksi terbesar dilakukan dengan menggunakan baris 31, sedangakn

untuk menampilkan informasi barang yang termahal dari semua barang yang dibeli oleh

pelanggan dilakukan dengan menggunakan method pada baris 58.

Pada Contoh 5.12 digunakan sebagai driver yang akan mengeksekusi aplikasi.

Adapun hasil eksekusi program contoh 5.12 untuk proses input data pelanggan dan

barang-barang yang dibeli pelanggan direpresentasikan seperti pada gambar 5.9 dan

gambar 5.10, sedangkan hasil olahan data yang diperoleh seperti yang ditunjukkan pada

gambar 5.11.

Gambar 5.9 Hasil eksekusi program contoh 5.12 Input Data Pelanggan

Gambar 5.10 Hasil eksekusi program contoh 5.12 Input Data Barang

124


Gambar 5.11 Hasil eksekusi program contoh 5.12 menampilkan data input pelanggan

125


Soal Latihan Bab 5. 1. Apa yang dimaksud dengan tipe data dasar?

2. Jelaskan pengelompokkan tipe data dasar yang terdapat pada java.

3. Apa yang dimaksud dengan tipe data bentukan?

4. Apa yang dimaksud dengan array?

5. Jelaskan kelebihan dan kekurangan dari suatu array.

6. Jurusan Teknik Informatika, Intitut Teknologi Berbahagi, hendak

mengambangkan aplikasi sederhana untuk memfasilitas pengguna di dalam

menyimpan informasi data Mahasiswa dan Matakuliah yang diambilnya setiap

semerternya. Untuk Mahasiswa menyimpan data nim, nama, alamat, tanggal lahir,

nomor telepon. Untuk Matakuliah menyimpan data kode, nama, sks dan grade.

Setiap mahasiswa menempuh beberapa semester, dan setiap semester mahasiswa

mengambil beberapa matakuliah. Buatlah aplikasi java sederhana di dalam

memfasilitas pengguna di dalam menentukan :

a. Menentukan indeks presetasi semerter (IPS) setiap mahasiswa setiap

semester

b. Menentukan mahasiswa yang memiliki IPS terkecil di suatu semester

tertentu.

c. Menentukan mahasiswa yang memiliki IPS terbesar di suatu semester

tertentu.

d. Menentukan IPS rata-rata pada suatu semester tertentu.

e. Menentukan indeks prestasi komulatif (IPK) setiap mahasiswa pada suatu

angkatan

f. Menentukan mahasiswa yang memiliki IPK terkecil.

g. Menentukan mahasiswa yang memeiliki IPK terbesar.

126


Bab 6 Operator pada Java

Operator Java adalah karakter khusus yang memerintahkan compiler untuk

melakukan operasi terhadap sejumlah operand. Perintah operasi dispesifikasikan oleh

operator, dimana operand-nya adalah variabel, pernyataan, atau besaran literal. Sejumlah

operator hanya mengolah satu operand disebut operator unary. Beberapa operator

ditempatkan sebelum operand disebut operator prefiks (awalan), yang lainnya

ditempatkan setelah operand disebut operator postfiks (akhiran). Sedangkan jika

ditempatkan di antara dua operand disebut operator biner infiks.

Ada empat jenis dasar operator yaitu aritmatik, bitwise, relasi, dan logika. Setiap

operator ini adalah perintah kepada compiler agar melakukan operasi matematis atau

logika.

6.1 Operator Aritmatik

Operator aritmatik digunakan untuk proses matematis. Tabel 6.1 merupakan jenis

operator aritmatik yang berlaku pada Java.

Tabel 6.1. Jenis Operator Aritmatik

Operator Hasil

+ Penjumlahan

+= Persamaan Penjumlahan

- Pengurangan

-= Persamaan pengurangan

* Perkalian

*= Persamaan perkalian

/ Pembagian

/= Persamaan pembagian

% Modulus (sisa pembagian)

%= Persamaan modulus

++ Penambahan

-- Pengurangan

127


Untuk memberikan pemahaman tentang penggunaan operator aritmatik akan

diberikan source code seperti yang ditunjukkan pada contoh 6.1 listing code di bawah

ini;

Contoh 6.1:

/* * Nama File : OperasiModulus.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 class OperasiModulus{ 2 public static void main(String[] args){ 3 int a = 42;

4 int b = 2; 5 int c = 5; 6 7 System.out.println("Nilai a = " + a); 8 System.out.println("Nilai b = " + b); 9 System.out.println("Nilai c = " + c); 10 System.out.println("======================"); 11 System.out.println("Nilai a mod b = " + (a % b) ); 12 System.out.println("Nilai a mod c = " + (a % c)); 13 14 } 15 }


Pada contoh 6.1 baris 11 melakukan operasi modulus, sisa pembagian antara nilai 42

dengan nilai 2. Karena 42 dibagi dengan 2 menghasilkan nilai 21 dengan sisa pembagian

yang sama dengan nol, maka hasil eksekusi program baris 11 menghasilkan nilai 0.

128


Sedangkan pada baris 12 pembagian nilai 42 dengan 5 menghasilkan 8 dengan sisa

pembagian yang sama dengan 2, sehingga eksekusi program baris 12 menghasilkan nilai

2. Adapun hasil eksekusi program contoh 6.1 adalah seperti yang ditunjukkan pada

gambar 6.1.

6.2 Operator Bitwise Integer

Tipe numerik integer, long, int, short, char, dan byte memiliki kumpulan operator

tambahan yang dapat memodifikasi dan memeriksa bit-bit yang menyusun nilainya.

Adapun operator-operator bitwise integer yang terdapat pada Java adalah seperti yang

ditunjukkan pada tabel 6.2;

Tabel 6.2. Operator Bitwise Integer Java

Operator Hasil

~ Unary NOT

& AND

| OR

^ Exclusive OR

>> Shift kanan

>>> Shift kanan isi dengan nol

<< Shift kiri

<<< Shift kiri isi dengan nol

&= Pernyataan AND

|= Pernyataan OR

^= Pernyataan exclusive OR

>>= Pernyataan shift kanan

>>>= Pernyataan shift kanan isi dengan nol

<<= Pernyataan shift kiri

Untuk memberikan pemahaman tentang penggunaan operator bitwise integer Java akan

diberikan source code seperti yang ditunjukkan pada contoh 6.2 listing code di bawah ini;

129


Contoh 6.2 :

/* * Nama File : OperasiBitwiseEq.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 class OperasiBitwiseEq{

2 public static void main(String[] args){ 3 byte a = 2; // 2 00000010 4 byte b = 4; // 4 00000100

5 byte c = 3; // 1+2 00000011 6 7 System.out.println("Nilai a = " + a); 8 System.out.println("Nilai b = " + b); 9 System.out.println("Nilai c = " + c); 10 System.out.println("======================"); 11 System.out.println("Nilai a&b = " + (a&b)); 12 System.out.println("Nilai a|b = " + (a|b)); 13 System.out.println("Nilai a^b = " + (a^b)); 14 15 System.out.println("======================"); 16 System.out.println("Nilai a&c = " + (a&c)); 17 System.out.println("Nilai a|c = " + (a|c)); 18 System.out.println("Nilai a^c = " + (a^c)); 19 20 a>>=1; 21 b<<=2; 22 c>>=4; 23 System.out.println("======================"); 24 System.out.println("Nilai a = " + a); 25 System.out.println("Nilai b = " + b); 26 System.out.println("Nilai c = " + c); 27 28 } 29 }

Pada baris 11 melakukan operasi AND, antara nilai a dengan nilai b. Sebelum melakukan

operasi AND runtime java terlebih dahulu mengkonversi variabel a ke nilai biner

kemudian nilai biner a dan b dieksekusi dengan operator AND. Nilai operasi AND akan

bernilai 1 jika kedua parameternya bernilai 1 selain itu akan bernilai 0 akibatnya hasil

operasi baris 11 akan menghasilkan nilai 0. Pada baris 12 melakukan operasi OR. Nilai

operasi OR akan bernilai 1 jika salah satu dari nilai biner parameter bernilai 1, sehingga

baris 12 akan menghasilkan nilai biner 00000111, yang sama dengan nilai int 6. Dengan

130


mengimplementasikan source code contoh 6.2 akan diperoleh hasil eksekusi program

seperti pada gambar 6.2.


6.3 Operasi Relasi

Untuk membandingkan dua buah nilai yang menyatakan kesamaan dan urutan,

Java memiliki kumpulan operator relasi seperti yang diberikan pada tabel 6.3 berikut ini.

Tabel 6.3 Operasi Relasi

Operator Hasil

== Sama dengan

!= Tidak sama dengan

> Lebih besar dari

< Lebih kecil dari

>= Lebih besar dari atau sama dengan

<= Lebih kecil dari atau sama dengan

6.4 Operator Logika Boolean

Operator logika boolean dalam tabel di bawah ini bekerja hanya pada operand

boolean. Adapun operator-operator logika Boolean yang terdapat pada Java adalah

seperti yang ditunjukkan pada tabel 6.4.

131


Tabel 6.4 Operator Logika Boolean

Operator Hasil

& Logika AND

| Logika OR

^ Logika XOR

|| Hubungan singkat OR

&& Hubungan singkat AND

! Hubungan singkat NOT

&= Pernyataan AND

|= Pernyataan OR

^= Pernyataan XOR

== Sama dengan

!= Tidak sama dengan

?: Operator ternary if-then-else

Untuk memberikan pemahaman yang lebih jelas tentang penggunaan operator logika

boolean pada Java, kita akan perhatikan contoh 6.3 yang diberikan.

Contoh 6.3 :

/* * Nama File : OperasiTernary.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 class OperasiTernary{ 2 public static void main(String[] args){ 3 int a = 42; 4 int b = 2;

5 int c = 0; 6 int d = (b==0) ? 0 :(a/b) ; 7 int e = (c==0) ? 0 :(a/c);

8 9 System.out.println("Nilai a = " + a); 10 System.out.println("Nilai b = " + b); 11 System.out.println("Nilai c = " + c); 12

132


13 System.out.println("======================"); 14 System.out.println("Nilai (b==0) ? 0 :(a/b) = " + d ); 15 System.out.println("Nilai (c==0) ? 0 :(a/c) = " + e ); 16 17 } 18 }


Pada baris 14 contoh 6.3 terdapat operator ternary dimana runtime java pertama sekali

akan mencek, apakah nilai dari variabel b sama dengan nol, karena nilai b sama dengan 2,

maka operasi yang dilakukan adalah operasi a/b, yang akan menghasilkan nilai 21.

Sedangkan pada baris 15 karena nilai c sama dengan nol, maka operasi yang dieksekusi

adalah pemberian nilai nol. Adapun hasil eksekusi program yang diperoleh dari source

code contoh 6.3 adalah seperti yang ditunjukkan pada gambar 6.3.

6.5 Preseden Operator

Dalam aljabar dasar telah diperkenalkan bahwa perkalian dan pembagian

memiliki preseden lebih tinggi dari pada penjumlahan dan pengurangan. Tabel 6.5

berikut menunjukkan urutan semua operasi yang mungkin pada Java, dari preseden

tertinggi sampai terendah. Ini menyatakan bahwa dengan tidak melakukan tanda semi

kolom, maka operasi yang dilakukan oleh runtime Java adalah urutan operasi seperti

yang dinyatakan pada tabel 6.5.

133


Tabel 6.5 Tabel Presenden Operator

Tertinggi

( ) [ ] .

++ -- ~ !

* / %

+ -

>> >>> <<

> >= < <=

== !=

&

^

|

&&

||

?:

=

Terrendah

134


Soal Latihan Bab 6. 1. Apa yang dimaksud dengan operator? 2. Sebutkan jenis-jenis operator yang terdapat pada java? 3. Diberikan penggalan listing code seperti berikut ini :

int a = 62;

int b = 17; Tentukan hasil keluaran dari

a. System.out.println("Nilai a mod b = " + (a % b) ); b. System.out.println("Nilai a&b = " + (a&b)); c. System.out.println("Nilai a|b = " + (a|b));

d. System.out.println("Nilai a^b = " + (a^b)); e. System.out.println("Nilai (b==0) ? 0 :(a/b) = " + (b==0) ? 0 :(a/b)); f. System.out.println("Nilai (b==17) ? 0 :(a/b) = " +(b==17) ? 0 :(a/b) );

135


Bab 7 Pengaturan Alur Program

Pembuatan pilihan keputusan merupakan suatu elemen dasar dalam semua

pemrograman. Pemilihan keputusan merupakan suatu hal yang sering kita gunakan.

Misalkan premis, jika saya lulus SMA saya akan melanjutkan kuliah jurusan informatika,

jika tidak saya akan berwirausaha. Dalam istilah pemrograman pengambilan keputusan

ini diatur di dalam pengaturan alur program.

Pengaturan alur Program adalah cara suatu bahasa pemrograman membuat aliran

eksekusi berkembang dan bercabang sesuai dengan perubahan keadaan data.

Pencabangan, perulangan, pengiriman, dan pemanggilan sub-rutin merupakan bentuk-

bentuk pengaturan aliran program.

7.1 Pembuatan Keputusan

Seperti yang dinyatakan di atas pemilihan keputusan sangat sering terjadi.

Pemilihan keputusan ini di dasarkan akan hasil nilai perbandingan yang diperoleh. Dalam

pemrograman sangat diperlukan pengetahuan akan kemampuan programer di dalam

membuat perbandingan antara variabel, konstanta, dan nilai ekspresi, yang selanjutkan

akan dieksekusi sesuai dengan nilai perbandingan yang diharapkan.

Java menyediakan 6 operator reasional untuk membandingkan dua nilai data yang

akan diperbandingkan. Setiap nilai data yang diperbandingkan dapat berupa variabel,

konstanta, atau ekspresi, seperti yang dijelaskan pada tabel 7.1 berikut.

Tabel 7.1 Operator perbandingan pada Java

Operator

relasional

Keterangan

> Menghasilkan nilai true jika nilai operand kiri lebih besar dari

operand kanan, dan untuk sebaliknya bernilai false

>= Menghasilkan nilai true jika nilai operand kiri lebih besar atau

sama dengan nilai operand kanan, dan untuk sebaliknya bernilai

false

136


= = Menghasilkan nilai true jika nilai operand kiri sama dengan nilai


! = Menghasilkan nilai true jika nilai operand kiri tidak sama dengan

nilai operand kanan, dan untuk sebaliknya bernilai false

< = Menghasilkan nilai true jika nilai operand kiri lebih kecil atau sama

dengan nilai operand kanan, dan untuk sebaliknya bernilai false

< Menghasilkan nilai true jika nilai operand kiri lebih kecil dari


Perlu diperhatikan bahwa, jika kita hendak menyimpan nilai hasil suatu

perbandingan maka kita mendeklarasikan variabel tersebut sebagai boolean.

Sebagai contoh, kita hendak menyimpan nilai variabel perbandingan antara nilai selisih

nilai x dengan y dengan penjumlahan a dengan b, seperti yang ditunjukkan dibawah ini.

boolean state = false; state = (x – y) < (a + b);

Operator relasional yang dipergunakan di dalam perbandingan di atas adalah “<”.

Pernyataan di atas menyatakan bahwa nilai state akan bernilai true, jika nilai (x-y) lebih

kecil dari nilai (a+b), sebaliknya nilai state akan tetap bernilai false.

7.2 Pencabangan

Java menyediakan sejumlah mekanisme untuk menghasilkan pengaturan bagian

program mana yang dijalankan, berupa pernyataan-pernyataan pencabangan. Statemen

pertama yang akan kita bahas didalam pengaturan program sebagai hasil dari

perbandingan adalah statemen if (jika).

7.2.1 if-else

Bentuk if-else menyebabkan eksekusi dijalankan melalui sekumpulan keadaan

boolean sehingga hanya bagian tertentu program yang dijalankan. Bentuk umum

pernyataan if-else

137


if(boolean-ekspresi) [statement1;]

else [else statement2;] Ini menunjukkan bahwa jiak boolean-ekspresi bernilai true (benar) maka statemen yang

akan dijalankan adalah statement1, tetapi jika boolean-ekspresi bernilai salah maka

pernyataan yang dijalankan adalah statement2.

Jika kita mengkaji “jika saya lulus SMA saya akan melanjutkan kuliah jurusan

informatika, jika tidak saya akan berwirausaha”, ini menyatakan bahwa jika ternyata

orang yang kita amati ternyata lulus SMA, maka dia akan melanjutkan perkuliahan

dengan jurusan informatika. Tetapi jika ternyata orang tersebut tidak lulus SMA, maka

yang akan dilakukan anak tersebut adalah berwirausaha.

Sering kali kita bertemu dengan suatu ekspresi yang mengeksekusi beberapa

statement jika nilai perbandingan ekspresinya bernilai benar atau salah. Seperti halnya

contoh berikut, “ jika saya lulus SMA saya akan melanjutkan kuliah jurusan informatika

dan saya akan belajar lebih sungguh-sungguh, jika tidak saya akan berwirausaha dan saya

akan private manajemen usaha bisnis”.

Jika kita menginginkan lebih dari satu statement setelah ekspresi if atau else maka

kita harus menggunakan kurung-kurawal, seperti yang ditunjukkan di bawah ini;

if(boolean-ekspresi) { [statement11;] [statement12;] . . [statement_1n;]

} else { [statement21;] [statement22;] . . [statement_2n;]

}

Ini menunjukkan bahwa jika boolean-ekspresi bernilai true (benar) maka statement yang

akan dijalankan adalah statement11, statement12, . . ., statement_1n, tetapi jika boolean-

138


ekspresi bernilai false (salah) maka pernyataan yang dijalankan adalah statement21,

statement22, . . ., statement_2n.

7.2.2 Statement if bersarang

Di dalam perbandingan ekpresi tidak semuanya langsung mengeksekusi statemen

yang diharapkan, tetapi terlebih dahulu melakukan pengecekan perbandingan nilai

ekspresi berikutnya. Dengan kata lain, statemen yang dieksekusi saat nilai ekspresi

bernilai benar adalah statemen if yang lain. Perbandingan semacam ini disebut statement

if bersarang, yaitu di dalam perbandingan ekpresi if terdapat perbandingan if yang lain.

Statemen bersarang dapat seperti ekpresi “jika saya lulus SMA dan jika saya lulus

seleksi jurusan informatika maka saya akan kuliah informatika, tetapi jika tidak dan jika

orang tua saya memberi modal maka saya akan berwirausaha”. Ekspresi ini

menunjukkan bahwa saat lulus SMA akan mencek nilai kebenaran dari kelulusan seleksi

jika nilai keduanya benar maka stamen yang akan dieksekusi adalah saya akan kuliah

informatika. Tetapi jika tidak lulus SMA dan orang tuanya memberi modal maka dia

akan berwirausaha. Bentuk umum statemen if bersarang dapat dinyatakan sebagai berikut

:

if(boolean-ekspresi_1) { if(boolean-ekspresi_11)

[statement_111;] [statement_112;] . . [statement_11n;]

else{ [statement_121;] [statement_122;] . . [statement_12n;]

} } else {

if(boolean-ekspresi_22) [statement_211;] [statement_212;] . . [statement_21n;]

139


else{ [statement_221;] [statement_222;] . . [statement_22n;]

} }

Contoh 7.1:

/* * Nama File : MainIfElse.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.io.*; 2 import java.util.*; 3 4 public class MainIfElse{ 5 6 public static void main(String[] args){ 7 String cmd;

8 int month=0; 9 String season; 10 BufferedReader inputUser = new BufferedReader(new InputStreamReader 11 (System.in)); 12

13 try{ 14 System.out.println("Pilih Bulan : "); 15 cmd = inputUser.readLine(); 16 month = (int)Integer.parseInt(cmd);

17 }catch(IOException e){ 18 return; 19 }catch(NumberFormatException e){ 20 System.out.println("Anda memasukkan data di luar format"); 21 } 22

23 if (month == 12 || month == 1 || month == 2 ){ 24 season = "Winter"; 25 }

26 else if (month == 3 || month == 4 || month == 5){ 27 season = "Spring"; 28 } 29 else if (month == 6 || month == 7 || month == 8){ 30 season = "Summer";

31 }else if (month == 9 || month == 10 || month == 11){ 32 season = "Autumn";

140


33 }else{ 34 season = "month good"; 35 } 36 System.out.println("Musimnya adalah " + season); 37 } 38 }

Pada contoh 7.1 baris 14, pengguna diminta untuk memasukkan nomor bulan yang akan

ditentukan jenis musimnya dari keyboard. Karena semua masukan dari keyboard adalah

tipe data String, maka kita harus memparsing atau mengubah tipe data tersebut ke tipe

data int , seperti yang dinyatakan pada baris 15. Kemudian akan dicek jenis musin yang

sesuai untuk dimasukan kedalam identifier season yang sesuai, yang dilakukan pada baris

23 sampai 35. Pada baris ke 36 akan ditampilkan musim yang bersesuaian dengan

masukan bulan yang dimasukkan pengguna. Adapun hasil eksekusi source code contoh

7.1 di atas akan diperoleh seperti yang ditampilkan pada gambar 7.1.


7.2.3 Operator Logika

Kita telah membahas penanganan statemen if sederhana. Tetapi dalam kenyataan

riel, kita sering diperhadapkan dengan penanganan statemen yang lebih komplek.

Penangan ini dilakukan dengan mengkombinasikan sejumlah kondisi yang dapat

mengeksekusi perbandingan secara bersamaan.

141


Pengkombinasian beberapa ekspresi sehingga memiliki nilai true atau false dapat

dilakukan dengan operator logika. Operator logika beroperasi pada nilai boolean yang

juga merujuk sebagai operator boolean. Operator logika memiliki 5 operator yang

beroperasi pada operator boolean, yaitu

Tabel 5.2 Operator Logika

Simbol Name

& Logika AND (sama dengan)

&& Kondisi AND

| Logika OR

|| Kondisi OR

! Logika negasi (NOT)

7.2.3.1 Operasi boolean AND

Kita dapat menggunakan operator AND dengan simbol & atau &&, dimana nilai

kebenaran dari ekpresi yang dihasilkan akan bernilai true (benar) jika kedua nilai ekspresi

yang diperbandingkan bernilai benar. Perbedaan antara operator AND & dengan &&

adalah terletak pada kondisionalnya, yaitu dalam operator && tidak akan mengevaluasi

semua ekspresi yang akan diperbandingkan, saat terdapat ekspresi yang bernilai salah

disebelah kiri maka perbandingan dihentikan dan menghasilkan nilai ekspresi yang

bernilai salah. Sedangkan operator & selalu mengevalusi semua nilai ekspresi yang akan

diperbandingkan, sehingga dalam penggunaan operator & akan lebih lambat

dibandingkan operator &&.

Misalkan, perhatikan source code berikut ini:

int bil = 15

if (bil < 10 && (5*bil + 125) > 150 )

System.out.println(“nilai hasil bil ” + bil);

Ini menunjukkan bahwa saat ekspresi (5*bil + 125) > 150 tidak akan pernah dieksekusi

karena ekspresi bil < 10 bernilai salah.

142


7.2.3.2 Operasi Logika OR

Kita dapat mengguna operasi OR, | atau ||, akan menghasilkan nilai ekspresi true

jika salah satu nilai ekspresinya bernilai benar. Sama halnya dengan operator logika

AND, perbedaan antara operator OR | dengan || adalah terletak pada kondisionalnya,

yaitu dalam operator || tidak akan mengevaluasi semua ekspresi yang akan

diperbandingkan, saat terdapat ekspresi di sebelah kiri yang bernilai benar maka

perbandingan dihentikan dan menghasilkan nilai ekspresi yang bernilai benar. Sedangkan

operator | selalu mengevalusi semua nilai ekspresi yang akan diperbandingkan, sehingga

dalam penggunaan operator || akan lebih cepat dibandingkan operator |. Operasi logika

OR akan bernilai salah jika semua nilai ekspresi bernilai salah.

Misalkan, perhatikan source code berikut ini;

if (ipk > 3.5 || (lamaKuliah) <= 8 ) // lamaKuliah dibawah 8 semester

System.out.println(“mahasiswa Lulusan Terbaik”);

Ini menunjukkan bahwa saat ekspresi ipk > 3.5 bernilai benar maka ekspresi lamaKuliah <

=8 tidak akan pernah dieksekusi.

7.2.3.3 Operasi Logika NOT

Operator logika yang ketiga adalah NOT, !, yang digunakan untuk menyatakan

invers atau kebalikan dari nilai kenarannya. Misalkan suatu variabel state yang tipenya

boolean diinisialisasi true, maka nilai dari !state akan berubah menjadi false.

7.2.4 Statemen break

Istilah break mengacu pada proses memecahkan blok program. Proses tersebut

memerintahkan runtime untuk menjalankan program di belakang blok tertentu. Untuk

dapat ditunjuk, suatu blok diberi nama, dan java memiliki bentuk label untuk menyatakan

nama suatu blok. Pada bahasa pemrograman lain, terdapat pernyataan goto yang

digunakan untuk mencabangangkan suatu blok program ke sembarang blok program

lainnya. Perhatikan contoh berikut :

143


Contoh 7.2:

/* * Nama File : PenggunaanBreak.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class PenggunaanBreak{

2 public static void main (Straing args[ ]){ 3 boolean t = true; 4 a: { 5 b: { 6 c: { 7 System.out.println(“Sebelum di break”); 8 if (t) 9 break b; 10 System.out.println(“Block b tidak eksekusi”); 11 } 12 System.out.println(“Kel blok c tapi b tdk dieksekusi”); 13 } 14 System.out.println(“Ini diluar blok b di dalam blok a”); 15 } 16 } 17 }


Pada contoh 7.2, pertama sekali akan mengeksekusi baris 7, kemudian masuk ke baris 8.

Saat mengeksekusi baris 8 terdapat kondisional if untuk mencek nilai dari identifier t.

Karena t bernilai true maka akan mengeksekusi break b, ini maksudnya adalah blok b,

144


yaitu mulai baris 5 sampai baris 13 akan di break, sehingga semua instruksi yang ada

pada blok tersebut tidak akan dieksekusi. Akibatnya akan masuk ke listing code pada

baris ke 14. Jika kita mengeksekusi source code di atas akan diperoleh bagian break

bekerja seperti yang ditampilkan pada gambar 7.2.

7.2.5 Statement switch

Pernyataan switch memampukan kita untuk memilih dari berbagai pilihan yang

ada yang telah di set pada nilai tertentu. Ekspresinya harus menghasilkan nilai yang

bertipe char, byte, short, atau int, tetapi tidak diperbolehkan long. Pada umumnya kita

menggunakan statemen switch untuk memilih satu ekspresi dari berbagai ekspresi yang

yang dapat dipilih. Dengan kata lain, pernyataan switch memberikan suatu cara untuk

mengirim bagian program berdasarkan nilai suatu variabel atau pernyataan tunggal.

Bentuk umum pernyataan switch adalah;

switch (ekspresi){ case value1: break; case value2: break; case value_n: break;

}

kata kunci break sering digunakan dalam pernyataan switch tanpa label menyebabkan

eksekusi pencabangan langsung menuju ke akhir pernyataan switch. Jika kita tidak

menuliskan break, maka eksekusi akan dilanjutkan ke dalam case selanjutnya.

Contoh 7.3:

/* * Nama File : SwitchCase.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class SwitchCase{

145


2 public static void main(String[] args){ 3 int a = 2; 4 5 switch(a){ 6 case 2: { 7 System.out.println("test 2"); 8 break; 9 } 10

11 case 1: { 12 System.out.println("test 1"); 13 break; 14 } 15 case 0: { 16 System.out.println("test 0"); 17 break; 18 19 } 20 } 21 } 22 }


Pada contoh 7.3 baris ke 3, identifier a yang bertipe int telah diinisialisasi dengan nilai 2.

Pada baris ke 5, dengan menggunakan statement switch akan ditangkap oleh case yang

bersesuaian dengan nilai a. Karena a sama dengan 2, maka yang akan dieksekusi adalah

blok case 2, yang terdapat pada baris 7. Karena pada baris berikutnya, yaitu baris 8,

terdapat statement break, maka akan keluar dari blok switch. Jadi baris 9 sampai 20 tidak

akan dieksekusi. Tetapi jika kita tidak menyatakan break, maka baris berikutnya akan

146


tetap dieksekusi. Adapun hasil eksekusi source code contoh 7.3 di atas akan diperoleh

seperti yang ditampilkan pada gambar 7.3.

7.3 Pengulangan

Looping artinya mengulangi eksekusi blok program tertentu sampai tercapai kondisi

untuk menghentikannya (terminasi). Setiap perulangan memiliki empat bagian :

1. inisialisasi, program yang menyiapkan keadaan awal perulangan.

2. badan program, pernyataan yang ingin kita ulangi

3. iterasi, program yang kita jalankan setelah badan program

4. terminsasi, pernyataan boolean yang diperiksa setiap kali selama perulangan

untuk melihat apakah sudah waktunya menghentikan eksekusi.

Java memiliki tiga macam bentuk perulangan, yaitu :

1. while

pernyataan perulangan yang paling mendasar pada Java. Bentuk umum perulangan

while adalah

[initialization;] while(termination){ body; [iterasi;] }

Pada perulangan ini akan mengeksekusi body secara terus menerus selama

termination menghasilkan nilai true.

Contoh 7.4:

/* * Nama File : Display2.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class Display2 {

2 public static void main(String[] args) 3 { 4 int panjang = 10; 5 int lebar = 5;

147


6 int a = 1; 7 int b = 1; 8 int d = 1; 9 10 while(a <= panjang) 11 { 12 System.out.print("x"); 13 a++; 14 } 15 16 System.out.println(); 17

18 while(b <= (lebar - 2)) 19 { 20 System.out.print("x"); 21 int c = 1; 22 while( c <= (panjang - 2)) 23 { 24 System.out.print(" "); 25 c++; 26 } 27 28 System.out.println("x"); 29 b++; 30 } 31 32 while(d <= panjang)

33 { 34 System.out.print("x"); 35 d++; 36 } 37 38 } 39 }

Contoh 7.4 dugunakan untuk menggambarkan suatu balok dengan panjang 10 dan lebar 5

“x”, seperti yang akan dijelaskan berikut. Pada baris 4 dan 6 telah diinisialisasi nilai

panjang=10 dan a=1, sehingga pada 10 contoh 7.4 akan bernilai benar. Pada baris 12

akan mencetak nilai “x”, kemudian nilai a ditambahkan satu. Proses ini akan tetap

dilaksanakan sampai a > panjang, yaitu saat a sama dengan 11. Hasil eksekusi while

baris 10 sampai 14 adalah cetak “x” sebanyak 10 kali baris pertama. Kemudian akan

masuk ke bari 16 untuk mencetak baris baru atau untuk meletakkan cursor di baris

berikutnya. Karena yang dibutuhkan lebar sebanyak 5 “x”, sedangkan pada baris 1 telah

dicetak satu “x”, dan dibaris akhir juga nantinya akan dicetak satu “x”, maka tentunya

banyaknya “x” yang dibutuhkan untuk lebarnya adalah 3, yaitu (lebar-2), seperti yang

148


dinyatakan pada baris 18. Pada baris 20 akan mencetak “x”, kemudian pada while baris

22 sampai 26 yang dimulai pada index ke 1 sampai index ke 8, akan mencetak “ ”, yang

digunakan untuk membuat ruang kosong atau spasi sehingga didalam balok jadi kosong.

Baris 28 akan mencetak “x”, untuk menutup sisi balok. Proses ini terus dilakukan sampai

lebar sudah mencapai (lebar – 2). Baris 32 akan melakukan proses yang sama sepeti pada

baris 10, dengan tujuan untuk menutup sisi balok bagian bawah. Adapun hasil eksekusi

source code contoh 7.4 di atas akan diperoleh seperti yang ditampilkan pada gambar 7.4.


2. do-while

Terkadang kita ingin mengeksekusi badan program dengan perulangan while

sekurang-kurangnya sekali, biarpun pernyataan boolean-nya langsung menghasilkan

false, maka untuk memfasilitasi tersebut digunakan perulangan do-while. Bentuk

umumnya adalah;

[initialization;] do{ body; [iterasi;] } while(termination)

Pada perulangan ini akan mengeksusi body minimal satu kali, kemudian jika

pernyataan termination bernilai false, maka perulangan akan dihentikan sedangkan

jika bernilai true eksekusi akan berhenti.

149


Contoh 7.5:

/* * Nama File : Display3.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class Display3 2 {

3 public static void main(String[] args) 4 {

5 int panjang = 10; 6 int lebar = 5; 7 int a = 1; 8 int b = 1;

9 int d = 1; 10 11 do

12 { 13 System.out.print("x"); 14 a++;

15 }while(a <= panjang); 16 17 System.out.println(); 18 19 do

20 { 21 System.out.print("x");

22 int c = 1; 23 24 do 25 { 26 System.out.print(" "); 27 c++; 28 }while( c <= (panjang - 2)); 29 30 System.out.println("x"); 31 b++;

32 }while(b <= (lebar - 2)); 33 34 do

35 { 36 System.out.print("x"); 37 d++;

38 }while(d <= panjang); 39 40 } 41 }

150


Pada contoh 7.5 akan menghasilkan nilai yang sama seperti yang dinyatakan pada contoh

7.4. Pada contoh 7.5 ini kita menggunakan perulangan do-while, karena perulangannya

pasti akan dilakukan minimal satu kali, sedangkan proses lojik didalamnya sama. Adapun

hasil eksekusi source code contoh 7.5 di atas akan diperoleh seperti yang ditampilkan

pada gambar 7.5.


3. for

perulangan for merupakan cara praktis untukmenyatakan suatu perulangan. Bentuk

umum pernyataan for adalah;

for(initialitation; termination;iteration) { body; }

Contoh 7.6:

/* * Nama File : Display.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class Display 2 {

3 public static void main(String[] args) 4 {

5 int panjang = 20;

151


6 int lebar = 12; 7

8 for(int a = 1; a <= panjang; a++) 9 { 10 System.out.print("x"); 11 } 12 13 System.out.println(); 14

15 for(int b = 1; b <= lebar - 2; b++) 16 { 17 System.out.print("x"); 18

19 for(int c = 1; c <= panjang - 2; c++) 20 { 21 System.out.print(" "); 22 } 23 24 System.out.println("x"); 25 } 26

27 for(int d = 1; d <= panjang; d++) 28 { 29 System.out.print("x"); 30 } 31 } 32 }


Pada contoh 7.6 kita menggunakan perulangan for untuk mencetak suatu gambar balok

“x”, dengan panjang 20 dan lebar 12. Proses lojik didalam mencetak balok tersebut

hampir sama dengan yang dijelaskan pada contoh 7.4 dan contoh 7.5 di atas. Adapun

152


hasil eksekusi source code contoh 7.6 di atas akan diperoleh seperti yang ditampilkan

pada cambar 7.6.

Contoh 7.7:

/* * Nama File : DuaKondisi.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class DuaKondisi{ 2 public static void main(String[] args){

3 int a, b, c; 4

5 for (a= 1, b = 4, c=5; a>5 || c<10; a++, b--, c++){ 6 System.out.println("a = " + a + " b = " + b + " c = " + c); 7 } 8 } 9 }


Pada contoh 7.7 memberikan gambaran tentang penggunaan dua kondisional di dalam

perulangan for, yaitu apakah pernyataan (a>5 || c<10), sudah bernilai benar (true). Saat

eksekusi pertama looping for, a= 1, b = 4, c=5. Ini menunjukkan bahwa a>5 adalah false,

153


tetapi c < 10 adalah benar. Karena kondisional yang dicek adalah (a>5 || c<10), maka ini

akan bernilai benar sehingga akan dieksekusi di dalam blok for. Nilai identifier a dan

nilai identier c akan ditingkatkan satu, maka pada suatu saat nilai identifier a sama

dengan 6 dan nilai identifier c sama dengan 10. Tetapi karena (a>5 || c<10), maka

pernyataan ini juga akan tetap bernilai benar, sehingga prosesnya akan tetap looping

tanpa akhir. Adapun hasil eksekusi source code contoh 7.7 di atas akan diperoleh seperti

yang ditampilkan pada gambar 7.7.

Contoh 7.8 :

/* * Nama File : KontinuLabel.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class KontinuLabel{ 2 public static void main(String[] args){ 3 4 outer: for (int a = 0; a<10; a++){

5 for (int b = 0; b<10; b++){ 6 if(b>a){ 7 System.out.println(""); 8 continue outer; 9 } 10 System.out.print(" " + (a*b)); 11 12 } 13 } 14 System.out.println(""); 15 } 16 }

Pada baris 4 sampai baris 13 contoh 7.8 terdapat blok outer. Baris 5 akan mengeksekusi

perulangan for sebanyak 10 kali, yang dimulai dengan index b ke 0. Baris 6 terdapat

pengecekan apakah nilai identifier b lebih besar dari identifier a. Saat eksekusi pertama a

sama dengan 0 dan b sama dengan 0, maka ekspresi logika baris 6 akan bernilai salah

(false), maka yang akan dieksekusi adalah baris 10, yaitu akan menampilkan hasil kali

nilai identifier a dan identier b, yaitu 0. Pada peningkatan nilai identifier b, yaitu b sama

dengan 1, maka akan dieksekusi pada baris 7 dan 8, sehingga saat dieksekusi baris 8,

maka akan kembali ke baris 4, yaitu dengan mengeksekusi continue label outer.

154


Kemudian nilai a ditingkatkan dengan satu dari 0 ke 1, setelah itu akan mengeksekusi

pada baris 5. Pada perulangan for baris 5 kembali nilai b diinisialisasi dengan 0, maka

nilai b sama dengan 0 akan mengeksekusi baris 10 dan saat b sama dengan 1 juga akan

mengeksekusi baris 10. Ketika b sama dengan 2 maka ekspresi baris 6 akan bernilai

benar sehingga akan mengeksekusi baris 4 dan nilai a akan ditambahkan satu. Proses ini

dilakukan secara terus menerus sampai didapatkan nilai a telah mencapai 10. Adapun

hasil eksekusi source code contoh 7.8 di atas dengan menggunakan text editor eclipse

akan diperoleh tampilan Console seperti yang ditampilkan pada gambar 7.8.


Contoh 7.9 :

/* * Nama File : KondisiContinue.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class KondisiContinue{

2 public static void main(String[] args){ 3 4 for (int a = 0; a < 100; a ++){

5 6 if(a%2 == 0 ){ 7 System.out.print(a + " "); 8 continue; 9 }else if(a%3 == 0){

10 System.out.print(a + " ");

155


11 }else

12 continue; 13 System.out.println(""); 14 } 15 } 16 }

Pada baris 4 nilai a diinisialisasi dengan 0, kemudian pada baris 6 akan dicek bahwa 0

habis dibagi dengan 2 atau sisa bagi dari nilai 0 dengan nilai 2 adalah 0, sehingga akan

mengeksekusi baris ke 7. Karena baris 8 mengeksekusi contine label kosong, maka akan

dilanjutkan ke prosos looping for berikutnya, sehingga nilai a akan menjadi 1. Karena

nilai a, yaitu 1, sekarang tidak habis dibagi dengan 2 atau 3 makan akan dieksekusi pada

baris 11 dan akan mengeksekusi continue baris 12 yang akan meningkatkan nilai a

menjadi 2 dan baris ke 13 tidak akan dieksekusi. Ketika nilai a sama dengan 2 maka akan

mengeksekusi baris 7 dan melanjutkan baris 8 untuk meningkatkan nilai a, yaitu menjadi

3. Saat nilai a sama dengan 3 maka baris 9 bernilai benar akibatnya akan mengeksekusi

pada baris 10. Karena tidaka ada continue label kosong maka akan diteruskan ke baris 13

untuk mencetak baris berikutnya. Dengan roses yang sama dilakukan secara terus

menerus sampai nilai a mencapai 100. Ini menyatakan bahwa setiap nilai a yang habis

dibagi dengan 3 akan mengeksekusi baris 13, yang akan selalu mencetak ke baris

berikutnya. Adapun hasil eksekusi source code contoh 7.9 di atas akan diperoleh seperti

yang tampilan pada gambar 7.9.


156


Contoh 7.10 : /* * Nama File : Prima.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.io.*; 2 import java.util.*; 3

4 public class Prima{ 5 public static void main(String argv[]){ 6 String cmd;

7 int x; 8 9 BufferedReader inputUser = newBufferedReader(new 10 InputStreamReader (System.in)); 11 12

13 try{ 14 System.out.println("Masukkan bilangan : "); 15 cmd = inputUser.readLine(); 16 x = (int)Integer.parseInt(cmd); 17 System.out.println("========================="); 18 19 getPrima(x);

20 }catch(IOException e){ 21 System.out.println("Data yang anda masukkan tidak sesuai "); 22 } 23 } 24 public static void getPrima(int x){

25 int[ ] primes = new int[x]; 26 primes[0] = 2; 27 primes[1] = 3;

28 int count = 2; 29 int number = 5; 30

31 outer: 32 for( ; count<primes.length; number+=2 ){ 33

34 long limit = (long)Math.ceil(Math.sqrt((double)number));

35 for(int i=1; i<count && primes[i]<=limit; i++) 36 if(number % primes[i] == 0)

37 continue outer; 38 39 primes[count++] = number; 40 41 }//for(count) 42 for(int i=0; i<primes.length; i++){

157


43 System.out.print(primes[i]+"\t");

44 if(i%10 == 0) 45 System.out.println(); 46 } 47 } 48 }


Contoh 7.10 digunakan untuk menampilkan bilangan prima sesuai dengan banyak

bilangan prima yang diinginkan oleh pengguna. Baris 14 akan memberikan pesan

“Masukkan bilangan”, yang ditunjukkan untuk memberikan informasi ke pengguna berap

banyak bilangan prima yang hendak dibangkitkan. Kemudian masukan pengguna akan

ditangkap listing code pada baris yang ke 15 dan akan diparsing masukan pengguna ke

tipe data int . Pada baris 19 akan mengeksekusi getPrima( ), dengan nilai argumen sesuai

dengan masukan pengguna sehingga akan memanggil method pada baris 24. Pada baris

32 digunakan peningkatan 2, karena bilangan yang mungkin menjadi bilangan prima

bilangan ganjil. Pada baris 36 digunakan untuk menguji, apakah bilangan berikutnya

yang diambil dari identifier, number, habis dibagi dengan suatu bilangan prima yang

sudah ada sebelumnya pada list bilangan prima, jika ada akan kembali ke baris 31 saat

mengeksekusi countinue label outer pada baris 37. Jika eksekusi baris 36 menghasilkan

nilai yang salah maka akan nilai number akan dimasukkan ke list bilangan prima, seperti

yang dinyatakan pada baris 39. Proses yang sama akan terus dilakukan sampai elemen

bilangan prima yang dibangkitkan sama dengan jumlah bilangan prima yang diminta oleh

pengguna, yaitu count<primes.length bernilai salah. Pada baris 42 digunakan untuk

158


mencetak bilangan prima yang dibangkitkan kepada pengguna. Adapun hasil eksekusi

source code Contoh 7.10 di atas akan diperoleh seperti yang tampilan pada Gambar 7.10.

Contoh 7.11 : /* * Nama File : WordCount.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * Create by : Jasman Pardede * @version 1.1 */ 1 import java.io.*; 2 import java.util.*; 3 4 public class WordCount{ 5 6 static String teks = "Sekarang kita lagi belajar switch \n "+ 7 "Kita mau menghitung jumlah kata \n" + 8 "Kita juga mau menghitung jumlah baris \n"; 9 10 static int panjangKata = teks. length(); 11 12 public static void main(String[] args){ 13 boolean kata = false; 14 int jmlKarakter = 0; 15 int jmlKata = 0; 16 int jmlBaris = 0; 17 int jmlKar_a = 0; 18 19 for(int i = 0; i<panjangKata; i++){ 20 char c = teks.charAt(i); 21 jmlKarakter++; 22 23 switch(c){ 24 case '\n': 25 jmlBaris++; 26 case '\t': 27 case ' ' : 28 if(kata){ 29 jmlKata++; 30 kata = false; 31 } 32 break; 33 case 'a' : 34 { 35 jmlKar_a ++; 36 break; 37 }

159


38 default: 39 kata = true; 40 } 41 } 42 System.out.println("\t jumlah Baris " + jmlBaris + "\t jumlah Kata : " + jmlKata ); 43 System.out.println("Jumlah Karakter : " + jmlKarakter + "\t Jumlah huruf a " + 44 jmlKar_a); 45 System.out.println("Jumlah huruf + spasi " + panjangKata); 46 } 47 }


Fungsi dari listing code contoh 7.11 adalah untuk menghitung banyaknya jumlah baris,

kata, huruf, karakter, dan huruf tertentu. Pada baris 6 kita telah menginisialisasi identifier

teks dengan tiga baris kalimat. Pada baris 10 kita mengambil nilai banyaknya karakter

yang telah diinisialisasi pada identifier teks, yaitu dengan menggunakan method length()

yang dimiliki oleh class String yang nilainya dimasukkan ke nilai identifier

panjangKata. Pada baris 19 kita melakukan perulangan sebanyak panjangKata yang

telah diperoleh pada bari 10. Pada baris 10 kita mengambil satu buah String dan

mengubah tipe data String ke tipe data char dengan menggunakan method charAt(i) ,

yang dimiliki oleh class String yang akan dimasukkan ke karakter c, seperti yang

dinyatakan pada baris 20. Kemudian karakter-karakter yang diambil satu per satu dari

String teks akan dicek menggunakan switch-case. Jika karakter yang diambil adalah ‘\n’,

160


maka akan diperoleh penambahan satu baris baru seperti yang dinyatakan pada baris 24.

Jika di case ‘ ’ dan ‘\t’ maka akan diperoleh penambahan satu kata baru, seperti yang

dinyatakan pada baris 26 dan 27. Jika karakter yang diambil adalah ‘a’, maka jumlah

karakter akan akan ditambahkan dengan satu seperti yang dinyatakan pada baris 35. Pada

baris 42 sampai 46 menampilkan hasil yang diperoleh dari mesin kata yang telah

diproses. Adapun hasil eksekusi source code contoh 7.11 di atas akan diperoleh seperti

yang ditampilkan pada gambar 7.11.

Contoh 7.12 : /* * Nama File : Fibonaci.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.io.*; 2 import java.util.*; 3 4 public class Fibonaci{ 5 public static void main(String[] args){ 6 7 String cmd; 8 int x; 9 10 BufferedReader inputUser = new BufferedReader(new 11 InputStreamReader(System.in)); 12 13 try{ 14 System.out.println("Masukkan Bilangan : "); 15 cmd = inputUser.readLine(); 16 x = (int)Integer.parseInt(cmd); 17 getFibonaci(x); 18 }catch(IOException e){ 19 System.out.println("Data yang anda masukkan tidak sesuai "); 20 } 21 } 22 23 public static void getFibonaci(int x){ 24 int fibOld = 0; 25 int fibNew = 1; 26 System.out.println(" *========================* "); 27 28 for (int i=0; i<=x; i++){ 29 System.out.print("\t " + fibNew); 30 fibNew = fibNew + fibOld;

161


31 fibOld = fibNew-fibOld; 32 } 33 } 34 }

Fungsi dari listing code 7.12 digunakan untuk membangkitkan bilangan fibonacci

sebanyak yang diminta oleh pengguna dengan penjelasan yang dinyatakan berikut ini.

Pada baris 14 contoh 7.12 pengguna diminta untuk memasukkan berapa banyak bilangan

fibonacci yang akan dibangkitkan. Baris 15 sistem akan menangkap masukan pengguna

dan baris 16 masukkan pengguna akan diparsing ke tipe data int . Baris 17 akan

mengeksekusi getFibonaci(x), yang memanggil menthod getFibonaci(int x) yang terdapat

pada baris 23. Pada baris 23 sampai 32 melakukan proses pembangkitan bilangan

fibonacci dan menampilkan ke pengguna dengan menggunakan perulangan for serta

mengikuti aturan dari suatu bilangan fibonacci. Adapun hasil eksekusi source code

contoh 7.12 di atas akan diperoleh seperti yang ditampilkan pada gambar 7.12.


162


Soal Latihan Bab 7. 1. Buatlah program java sederhana untuk menyimpan 10 data bertipe int dengan

mengunakan perulangan for. 2. Buatlah program java sederhana untuk menyimpan 10 data bertipe int dengan

mengunakan perulangan while. 3. Buatlah program java sederhana untuk menyimpan semua masukan pengguna

yang bertipe data double dengan mengunakan perulangan do-while. Kemudian tentkan rata-rata dan nilai terkecil dan terbesar yang dimasukkan pengguna.

4. Buatlah program java sederhana untuk menentukan masukan pengguna, apakah huruf vokal atau konsonan dengan menggunakan kondisional if.

5. Buatlah program java sederhana untuk menentukan masukan pengguna, apakah huruf vokal atau konsonan dengan menggunakan kondisional switch-case.

163


Bab 8 Klasifikasi, Generalasasi dan Spesifikasi

Dalam kehidupan sehari hari, kita sering menemui beberapa objek yang memiliki

atribut dan fungsi yang terkadang sama dengan objek lainnya. Sehingga objek-objek yang

memiliki atribut dan fungsi yang sama tersebut dapat dikelompokan menjadi satu

kelompok. Objek-objek dengan pendefinisian yang sama dapat dikelompokkan dan

didefinisikan ke dalam satu class. Aksi dari pengidentifikasian dan pengkategorian

objek-objek yang sama ke dalam class-class dikenal sebagai klasifikasi (classification) di

dalam pemodel an berorientasi objek. Dalam bab ini, kita akan memperlajari bagaimana

objek-objek dikelompokkan kedalam class-class dan bagaimana relasi antar class dapat

diorganisasikan ke dalam suatu class secara hirarki menggunakan mekanisme

generalisasi dan spesifikasi.

8.1 Klasifikasi Table 6.1. Berbagai mahluk hidup

No Nama atribut Kemampuan 1 Tikus • Bertulang belakang

• Memiliki kelenjar susu • Memiliki rambut • Berdarah panas

• Berkembang biak dengan melahirkan • Berpindah menggunakan kaki • Bernapas dengan paru-paru

2 Kodok • Bertulang belakang, • Berdarah dingin • hidup di air dan di daratan • Tubuh diselubungi kulit berlendir • Hewan berdarah dingin • Memiliki dua pasang kaki • Mata memiliki selaput membran niktitans

• Bertelur di air, • Di air bernapas dengan ingsang • Di darat Bernapas dengan paru-paru • Dapat melompat dan berenang dengan

kaki

3 Koki • Bertulang belakang • Berdarah dingin • Memiliki sirip

• Hidup di air • Bernapas dengan insang • Berkembang biak dengan bertelur • Mampu berenang

4 Buaya • Bertulang belakang • Berdarah dingin • Memiliki sisik yang menutupi tubuh • Memiliki dua pasang kaki

• Berkembang biak dengan bertelur • Berpindah dengan menggunakan kaki

dan melata

5 Kelinci • Bertulang belakang • Berkembang biak dengan melahirkan

164


• Memiliki kelenjar susu • Memiliki rambut • Berdarah panas

• Berpindah menggunakan kaki • Bernapas dengan paru-paru

6 Burung Kolibri

• Hewan Bertulang belakang • Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh

• Berkembang biak dengan bertelur • Bernapas dengan paru-paru • Dapat terbang dengan sayap • Dapat berjalan dengan kaki

7 Katak • Bertulang belakang, • hidup di air dan di daratan • Tubuh diselubungi kulit berlendir • Hewan berdarah dingin • Memiliki dua pasang kaki • Mata memiliki selaput membran niktitans


kaki

8 Kuda • Bertulang belakang • Memiliki kelenjar susu • Memiliki rambut • Berdarah panas


9 Bebek • Hewan Bertulang belakang • Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh


10 Simpanse • Bertulang belakang • Memiliki kelenjar susu • Memiliki rambut • Berdarah panas


11 Kura-kura • Bertulang belakang • Berdarah dingin • Memiliki sisik yang menutupi tubuh • Memiliki dua pasang kaki •


dan melata

12 Lele • Bertulang belakang • Berdarah dingin •

• Hidup di air • Bernapas dengan insang • Berkembang biak dengan bertelur

13 Burung Unta

• Hewan Bertulang belakang • Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh


14 Penyu • Bertulang belakang • Berdarah dingin • Memiliki sisik yang menutupi tubuh • Memiliki dua pasang kaki •


dan melata

15 Pari • Bertulang belakang • Berdarah dingin


16 Lalat • Memiliki ruas-ruas yang bertungkai enam • Memiliki sayap

• Berkembang biak dengan bertelur • Berpindah dengan terbang

165


menggunakan sayap 17 Elang • Hewan Bertulang belakang

• Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh


18 Ular • Bertulang belakang • Berdarah dingin • Memiliki sisik yang menutupi tubuh •

• Berkembang biak dengan bertelur • Berpindah dengan menggunakan

tubuh (melata)

19 Merpati • Hewan Bertulang belakang • Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh


20 Kumbang • Memiliki ruas-ruas yang bertungkai enam • Memiliki sayap


menggunakan sayap 21 Salamander • Bertulang belakang,

• hidup di air dan di daratan • Tubuh diselubungi kulit berlendir • Hewan berdarah dingin • Memiliki dua pasang kaki • Mata memiliki selaput membran niktitans


kaki

22 Semut • Memiliki ruas-ruas yang bertungkai enam • Memiliki sayap


23 Cenderawasi • Hewan Bertulang belakang • Memiliki bulu • Memiliki sayap • Berdarah panas • Memiliki paruh


24 Ikan Mas • Bertulang belakang • Berdarah dingin •


25 Kupu-kupu • Memiliki ruas-ruas yang bertungkai enam • Memiliki sayap


menggunakan sayap

Setiap binatang memiliki nama dan deksripsi singkat tentang binatang tersebut.

Beberapa binatang memiliki informasi yang sama baik atribut maupun kemampuan yang

dimilikinya, seperti yang ditunjukkan pada tabel 6.1. Berdasarkan tabel 6.1 kita dapat

mengelompokkan binatang-binatang tersebut berdasarkan informasi yang dimiliki

bersama satu dengan yang lainnya. Kita mulai dengan Tikus, Kelinci, Kuda, dan

Simpanse. Masing-masing binatang ini jika kita perhatikan memiliki atribut bertulang

belakang, memiliki kelenjar susu, memiliki rambut, dan berdarah panas. Masing-masing

166


objek juga memiliki kemampuan yang sama, yaitu mampu berkembang biak dengan cara

melahirkan, dapat berpindah tempat dengan menggunakan kaki, dan bernapas dengan

paru-paru. Sehingga ke-empat objek tersebut dapat kita kelompokkan ke dalam kelompok

Mamalia.

Dengan cara yang sama, kita dapat mengelompokkan burung Kolibri, Burung Unta,

Elang, Bebek, Cenderawasi, dan Merpati ke dalam kategori Burung, karena memiliki

informasi yang sama, yaitu :

• Memiliki tulang belakang

• Memiliki paruh

• Memiliki kaki

• Sayap dan tubuhnya ditutupi oleh bulu

• Dapat terbang

• Bernapas dengan paru-paru

• Mampu bertelur

• Berdarah panas

Dengan cara yang sama, kita dapat mengelompokkan :

• Lele, Pari, Ikan Mas, dan Koki ke dalam kelompok Ikan .

• Buaya, Ular, Kura-kura, dan Penyu ke dalam kelompok Reptil

• Lalat, Kumbang, Semut, dan Kupu-kupu ke dalam kelompok Serangga

• Kodok, Katak, Salamander ke dalam kelompok Amfibi

Gambar 6.1 Kategori mahluk hidup tabel 6.1

167


Pada pemodelan berorientasi objek, tindakan atau kegiatan pengelompokkan objek-objek

kedalam suatu suatu kelompok tertentu berdasarkan kesamaan informasi yang dimiliki

oleh objek tersebut dikenal dengan istilah klasifikasi. Dari hasil pengelompokkan yang

kita lakukan maka, tabel 6.1 dapat kita nyatakan sebagai enam kategori dari mahluk

hidup, seperti yang ditunjukkan pada gambar 6.1.

8.2 Hirarki Relasi antar Class

Kelas-kelas yang dibentuk dapat diorganisisasikan dan direpresentasikan kedalam

suatu hirarki tertentu. Suatu class dapat diketahui sebagai suatu super class atau suatu sub

class, tergantung pada posisi class tersebut pada suatu class hirarki. Pada sub bab berikut

ini, kita akan membahas notasi dari super class dan subclass.

8.2.1 SuperClass dan SubClass

Gambar 6.2 Employee, SalesPerson, dan Manager

Pada bab 3 kita telah memperkenalkan Anton dan Budi sebagai penjual pada toko buku.

Kita juga telah menyebutkan bahwa Anton dan Budi sebagai objek dari SalesPerson

(subbab 3.1). Sekarang kita akan memperkenalkan dua karyawan baru, misalkan Olivia

dan Justin. Olivia dan Justin merupakan manajer pada toko buku. Karena Olivia dan

Justin sebagai manejer maka Olivia dan Justin memiliki sifat-sifat dan kemampuan yang

berbeda dengan yang dimiliki oleh Anton dan Budi. Sehingga kita dapat

mengelompokkan Olivia dan Justin sebagai objek-objek dari class yang berbeda,

168


misalkan objek dari class Manager. Karena ke-empat orang tersebut adalah karyawan

pada toko buku dan objek-objek dari class Employee, maka keterhubungan antara class-

class dan objek-objek yang ada dapat direpresentasikan seperti yang ditunjukkan pada

gambar 6.2.

Anton dan Budi merupakan objek-objek dari dua class, yaitu objek-objek dari class

SalesPerson dan juga objek-objek dari class Employee. Demikian juga dengan Olivia

dan Justin merupakan objek-objek dari dua class, yaitu objek-objek dari class Manager

dan juga objek-objek dari class Employee. Ini menunjukkan bahwa informasi tentang

Anton dan Budi sebagai penjual dan juga sebagai karyawan pada toko buku adalah

informasi yang benar. Ini menyatakan bahwa Anton dapat dikatakan sebagai seorang

penjual atau sebagai seorang karyawan.

Ketika Anton dinyatakan sebagai seorang karyawan ini menunjukkan bahwa

Anton sebagai objek yang lebih umum, tidak menspesifikasikan atau menyatakan secara

khusus kedudukan Anton itu sendiri pada toko buku. Tetapi saat Anto dinyatakan sebagai

penjual atau objek dari class SalesPerson maka Anto dinyatakan secara khusus, yaitu

Anton memilki informasi yang melekat pada dirinya tentang apa tugas dan tanggung

jawab dari seorang penjualan. Sebagai contoh, Anto dapat membuat order dan

memberikan komisi untuk setiap penjualan karena dia sebagai seorang penjual, tetapi

kegitan yang dilakukan Anton ini tidak dapat oleh Olivia, karena Olivia adalah seorang

manajer, walaupun Olivia dan Anton sebagai karyawan pada toko buku. Sebaliknya,

tugas dan tanggung jawab yang dimiliki oleh Olivia dan Justin tidak dapat dilakukan oleh

Anton dan Budi.

Class Employee dikatakan class general (umum) dari class SalesPerson dan class

Manager. Sebaliknya, class SalesPerson dan class Manager dikatakan class spesifikasi

(khusus) dari class Employee. Class Generalisasi dan Spesifikasi dapat diorganisasikan

ke dalam suatu class hirarki dengan cara menempatkan class yang general diposisi atas

dan class spesifik ditempatkan pada posisi yang lebih bawah.

Pada pemrograman berorientasi objek, suatu class spesifik lebih dikenal dengan

istilah subclass dari suatu class, sedangkan class yang lebih umum lebih dikenal dengan

istilah superclass dari class subclass. Berdasarkan gambaran class-class yang kita bahas

di atas, maka SalesPerson dan Manager merupakan suatu subClass dan class Employee,

169


sedangkan class Employee merupakan suatu superClass dari class-class SalesPerson dan

Manager.

8.2.2 Diagram Suatu Hirarki Class

Secara hirarki, hubungan antar class dapat dilihat dapat suatu diagram hirarki class

seperti yang ditunjukkan pada gambar 6.3. Kotak segi empat menyatakan sebagai suatu

class, notasi segitiga menyatakan relasi antar class secara hirarki dengan super class

berada pada posisi atas, sedangkan subclass ditempatkan pada posisi yang lebih bawah

dari super class-nya.

Gambar 6.3 Diagram Hirarki Class

Suatu class dapat menjadi suatu super class pada suatu class tertentu atau sebagai sub

class dari suatu class tertentu atau keduanya secara bersamaan tergantung pada posisi

class tersebut pada hirarki classnya. Pada gambar 6.3, class Person merupakan super

class dari class Customer dan Employee. Class Customer dan Employee merupakan

sub class dari class Person. Tetapi class Employee juga merupakan super class dari class

Manager dan SalesPerson. Jadi class Emploee merupakan suatu super class, jika dilihat

dari class Manager dan SalesPerson tetapi akan menjadi sub class bagi class Person.

Jadi dari gambar 6.3 dapat kita simpulkan sebagai berikut :

• Manager dan SalesPerson adalah subclass dari class Employee

170


• Employee adalah subclass dari class Person

• Person adalah superclass dari class Customer dan Employee

• Employee adalah superclass (bagi class Manager dan SalesPerson) dan suatu

subclass dari class Person.

8.3 Generalisasi

Generalisasi adalah suatu kegiatan pengambilan informasi (baik atribut maupun

behavior atau method) yang sama yang dimiliki oleh beberapa class kemudian dibentuk

ke dalam suatu class baru yang lebih umum; class-class yang diambil informasi yang

dimilikinya akan menjadi suatu subclass dari class yang baru. Sebagai contoh, class-class

Mamalia, Ikan, Burung, Reptilia dan Amfibia yang telah kita pada sub bab di atas, jika

kita lihat kesamaan informasi yang dimiliki oleh ke lima class tersebut sama-sama

memiliki atribut hewan tulang belakang. Berdasarkan kesamaan sifat inilah kita dapat

merujuk suatu class baru yang menjadi superclass dari ke lima class, misalkan class

Hewan-Bertulang-Belakang. Dengan demikian, saat kita mengambil suatu objek binatang

Kuda (sebagai suatu binatang Mamalia) juga merupakan suatu objek dari binatang

Hewan-Bertlang-Belakang, seperti yang dinyatakan pada tabel 6.1. Tetapi saat kita

mengambil Semut bukan suatu hewan yang bertulang belakang, sehingga dapat kita

masukkan kedalam suatu class baru, misalkan class Hewan-Tidak-Bertulang-Belakang.

Berdasarkan superclass dan subclass yang diperoleh, maka hirarki class dari class

binatang tersebut, seperti yang ditunjukkan pada gambar 6.4.

Gambar 6.4 Generalisasi class-class

171


Selanjutnya, saat kita melihat class Hewan-Bertulang-Belakang dan Hewan-

Tidak-Bertulang-Belakang tentu terdapat kesamaan informasi yang dimemilikinya,

misalnya berkembang biak, dapat berpindah tempat, bernafas, dan lain-lain. Sehingga

dari ke dua class ini dapat kita ciptakan suatu class baru, misalkan class Mahluk-Hidup,

yang menjadi superclass dari kedua class tersebut. Berdasarkan superclass dan subclass

yang diperoleh, maka hirarki class dari class binatang tersebut, akan diperoleh seperti


Gambar 6.5 Hirarki Class dari Mahluk Hidup

Gambar 6.5 menunjukkan bahwa class Mahluk-Hidup merupakan class yang

paling tinggi diantara semua class-class yang ada. Dengan kata lain class Mahluk-Hidup

merupakan class yang paling general dari hirarki class. Ini juga dapat menyakatan bahwa

Cenderawasi merupakan suatu objek dari class Burung, juga merupakan suatu objek dari

class Hewan-Bertulang, dan juga suatu objek dari class Mahluk-Hidup. Saat kita merujuk

Cenderawasi sebagai suatu objek dari class Mahluk-Hidup, maka kita menyatakan

Cenderawasi sebagai suatu yang lebih umum tanpa mengabaikan informasi khusus yang

dimiliki oleh Cenderawasi tersebut.

172


8.4 Spesifikasi

Kebalikan dari Generalisasi adalah Spesifikasi. Spesifikasi merupakan suatu kegiatan

pengambilan informasi yang berbeda yang dimiliki oleh objek-objek dari suatu class dan

kemudian menciptakan suatu class baru yang menjadi suatu subclass dari class

sebelumnya. Sebagai contoh, kita memperhatikan semut dan kuda yang merupakan objek

dari class Mahluk-Hidup. Jika kita amati informasi yang dimiliki kedua jenis binatang ini,

kita akan menemukan bahwa semut ternyata tidak memiliki tulang belakang, sedangkan

kuda memiliki tulang belakang. Akibatnya class Mahluk-Hidup kita dapat kelompokkan

ke dalam dua kelompok besar yaitu class Hewan-Bertulang-Belakang dan class Hewan-

Tidak-Bertulang-Belakang. Karena class Hewan-Bertulang-Belakang dan class Hewan-

Tidak-Bertulang-Belakang diperoleh dari hasil pengidentifikasian informasi secara

khusus dari objek-objek class Mahluk-Hidup maka class Hewan-Bertulang-Belakang dan

class Hewan-Tidak-Bertulang-Belakang merupakan subclass dari class Mahluk-Hidup.

Sama halnya dengan binatang kuda, lele, merpati, ular, dan katak merupakan

objek-objek dari class Hewan-Bertulang-Belakang. Tetapi jika kita perhatikan informasi

yang lebih khusus yang dimiliki oleh masing-masing binatang tersebut, maka kita akan

dapat mengelompokkan binatang-binatang tersebut menjadi lima kelompok besar, yaitu

class Mamalia, Ikan, Burung, Reptil, dan Amfibi. Masing-masing class baru yang

didapatkan akan menjadi subclass dari class Hewan-Bertulang-Belakang.

8.5 Pengorganisasi Hirarki Class

Class-class pada suatu diagram hirarki class dikelompokkan dengan suatu cara yang

disebut generalisasi dilakukan dengan cara menempatkan class-class mulai dari class

yang memiliki informasi yang paling khusus pada posisi yang paling dasar sampai class

yang memiliki informasi yang paling umum paling atas. Sebaliknya, saat kita

memposisikan class-class mulai dari class yang memiliki informasi paling umum pada

posisi paling atas sampai class-class yang memiliki informasi yang paling khusus pada

posisi yang paling dasar maka kita melakukan proses spesifikasi.

173


8.6 Class Abstract dan Class Konkrit

Pada beberapa class dalam suatu hirarki class yang sangat umum (general) kita

terkadang tidak perlu membuatkan objek-objek ril dari class tersebut. Kita tidak perlu

membuatkan objek ril karena atribut dan method yang dimiliki oleh class tersebut terlalu

umum, karena atribut dan method tersebut diharapkan akan digunakan pada subclass-

subclass-nya untuk tujuan digunakan ulang (reuse). Pada pemodelan berorientasi obejk,

class-class yang umum tersebut disebut sebagai class abstract. Sebagai contoh, class

Hewan-Bertulang-Belakang memiliki atribut dan method yang dimiliki oleh setiap class-

class Mamalia, Ikan, Burung, Reptil, dan Amfibi secara bersama. Sedangkan atribut dan

method yang dimiliki oleh clas Hewan-Tidak-Bertulang adalah atribut dan method umum

yang dimiliki dari class Serangga. Sehingga atribut dan method yang dimiliki oleh class

Mahluk-Hidup adalah atribut dan method yang dimiliki secara bersama dari class Hewan-

Bertulang-Belakang dan class Hewan-Tidak-Bertulang-Belakang.

Karena atribut dan method dari class Mahluk-Hidup, Hewan-Bertulang-Belakang dan

Hewan-Tidak-Bertulang-Belakang memiliki atribut dan method abstract maka ketiga

class ini merupakan class abstract, sehingga instansiasi objek dari ketiga class tersebut

hanya dapat dilakukan pada level yang lebih rendah, yaitu pada masing-masing subclass-

nya. Class-class yang tidak memiliki atribut atau method abstract disebut dengan class

konkrit. Class konkrit yaitu class yang dapat diciptakan suatu instansiasi objek dari class

tersebut. Berdasarkan hirarki class yang kita dapatkan maka class Mamalia, Ikan,

Burung, Reptil, Amfibi, dan Serangga termasuk kedalam class konkrit.

Pada Java, class abtract diimplementasikan dengan keyword abstract. Berdasarkan

hasil pernjelasan yang disampaikan di atas maka hirarki class mahluk hidup di atas dapat

diimplementasi ke Java seperti yang ditunjukkan pada Contoh 8.1 dan Contoh 8.2.

Contoh 8.1: class abstract

abstact class Mahluk-Hidup{ . . . }

abstact class Hewan-Bertulang-Belakang extends Mahluk-Hidup{ . . . }

174


abstact class Hewan-Tidak-Bertulang-Belakang extends Mahluk-Hidup{ . . . }

Contoh 8.2: class konkrit

class Mamalia extends Hewan-Bertulang-Belakang { Mamalia(String nama){}

. . . } class Ikan extends Hewan-Bertulang-Belakang { Ikan(String nama){}

. . . }

class Burung extends Hewan-Bertulang-Belakang { Burung(String nama){}

. . . } class Reptil extends Hewan-Bertulang-Belakang { Reptil(String nama){}

. . . } class Amfibi extends Hewan-Bertulang-Belakang { Amfibi (String nama){}

. . . } class Serangga extends Hewan-Tidak-Bertulang-Belakang { Serangga(String nama){}

. . . }

Berdasarkan Contoh 1 dan Contoh 2, maka

Mahluk-Hidup mh = new Mahluk-Hidup( );

merupakan pembentukan objek yang salah atau tidak valid, tetapi

Serangga ms = new Serangga(“Semut”);

merupakan pembentukan objek yang benar atau valid.

175


Soal Latihan Bab 8. 1. Jelaskan pengertian Generalisasi dan Spesifikasi menurut pendapat Saudara. 2. Jelaskan perbedaan antara class abstract dengan class konkrit. 3. Diberikan hirarki class seperti yang ditunjukkan pada gambar 8.6. Tentukanlah

class abstract dan class konkritnya.

Gambar 8.6 Hirarki class Transfortasi.

4. Berdasarkan gambar 8.6, implementasikanlah hirarki class tersebut ke dalam

bahasa pemrograman Java.

176


Bab 8 Eksepsi

Kita sebagai manusia yang membuat aplikasi maupun yang menggunakannya

sering malakukan kelalaian, akibatnya tiada program yang sempurna, dan juga tiada

pengguna program yang sempurna. Untuk mengatasi ketidak sempurnaan tersebut,

diperlukan suatu mekanisme yang membantu menangani error atau kesalahan yang

terjadi, baik saat pembuatan maupun implementasi program. Mekasnisme penanganan

error atau kesalahan pada pemrograman Java ditangani oleh exception.

Eksepsi adalah keadaan yang tidak normal yang muncul pada suatu bagian

program pada saat dijalankan. Banyak hal yang dapat menimbulkan keadaan tidak normal

saat instruksi program dijalankan. Keadaan tidak normal dapat terjadi dari keadaan

hardware yang digunakan misalnya crash, harddisk rusak dengan tiba-tiba, sehingga

program-program tidak bisa mengakses file-file tertentu. Keadaan tidak normal dapat

juga terjadi di saat pengembangan perangkat lunak, yang kurang memperhatikan data

masukan, misalkan saat programmer tidak membuat penangan kusus terhadap nilai nol

sehingga saat dieksekusi terjadi pembagian dengan bilangan nol, atau pengisian elemen

array melebihi jumlah elemen array yang dialokasikan dan sebagainya. Java

menggunakan eksepsi sebagai suatu cara di dalam menangani permasalahan-

permasalahan yang serius saat suatu program dijalankan.

Penanganan eksepsi pada Java membawa pengelolaan kesalahan program saat

dijalankan ke dalam orientasi objek. Eksepsi pada Java adalah objek yang menjelaskan

suatu keadaan eksepsi yang muncul pada suatu bagian program. Saat suatu keadaan

eksepsi muncul, suatu objek Exception dibuat dan dimasukkan ke dalam method yang

menyebabkan eksepsi, method tersebut dapat dipilih untuk menangani eksepsi

berdasarkan tipe eksepsi yang terjadi. Jadi suatu eksepsi pada Java adalah suatu objek

yang diciptakan atau dibuat saat keadaan tidak normal terjadi dalam suatu bagian

program. Keadaan eksepsi ini akan menyimpan informasi secara alami tentang

permasalahan yang terjadi.

177


8.1 Dasar-dasar Penanganan Eksepsi

Penanganan eksepsi pada Java diatur dengan lima kata kunci, yaitu try, catch,

throw, throws dan finally . Pada dasarnya try digunakan untuk mengeksekusi suatu

bagian program, dan jika muncul suatu kesalahan maka sistem akan melakukan throw

suatu eksepsi yang dapat kita catch berdasarkan tipe eksepsinya, atau yang dapat kita

finally untuk penanganan default. Jadi didalam penanganan eksepsi, kita akan selalu

menangani eksepsi di dalam blok try untuk mencoba mengamati apakah terjadi atau

terdapat suatu kesalahan kemudian kita akan menangkap kesalahan yang terjadi di dalam

blok catch atau blok program yang akan dieksekusi akan kita akhiri dengan finally.

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.

Bentuk umum penanganan eksepsi adalah sebagai berikut :

try { block code yang akan dieksekusi }catch (ExceptionType1 e){ // penanganan eksepsi yang terjadi akibat ExceptionType1 } catch (ExceptionType2 e){ // penanganan eksepsi yang terjadi akibat ExceptionType2 throw(e); // untuk melempar eksepsi yang terjadi }finally{ }

8.2 Tipe-Tipe Eksepsi

Suatu eksepsi selalu suatu objek dari beberapa subclass dari class standard

Throwable. Semua standard eksepsi dikelompokkan kedalam dua subclass, yaitu

subclass Error dan subclass Exception. Kedua subclass tersebut akan mengidentifikasi

kondisi eksepsi khusus yang terjadi. Hirarki dari eksepsi tersebut dapat dilihat seperti


178


Gambar 8.1 Subclass Exception

8.2.1 Eksepsi Error

Eksepsi yang didefinisikan oleh class Error dan merupakan subclass Throwable.

Eksepsi Error dicirikan dengan keadaan terjadinya eksepsi yang tidak dapat ditangani dan

terjadi saat program sedang dieksekusi. Eksepsi error saat di compile akan berjalan

dengan baik. Dengan kata lain, saat kita meng-eksekusi file class, maka kita tidak akan

dapat menemukan terjadinya suatu kesalahan, karena kesalahan hanya dapat diketahui

saat program sedang berjalan.

Eksepsi Error bukan merupakan eksepsi RuntimeException. Ada tiga eksepsi Error

dalam Java, yaitu

a. ThreadDeath, yaitu eksepsi yang terjadi saat suatu thread dieksekusi dipaksa

untuk dihentikan. Eksepsi ini tidak dapat ditangkan tetapi hanya dapat dilempar.

b. LinkageError , yaitu eksepsi yang terjadi karena ketidak sesuaian class atau

berusaha untuk menciptakan suatu objek dari suatu objek yang tidak ada.

c. Virtual MachineError , yaitu eksepsi yang terjadi akibat kegagalan di dalam

Java Virtual Machine.

179


8.2.2 Eksepsi RuntimeException

Eksepsi yang didefinisikan oleh class Exception dan dicirikan dengan keadaan

terjadinya eksepsi yang dapat ditangani. Eksepsi ini terjadi karena kesalahan di dalam

mendesain program atau saat memprogram sehingga eksepsi akan terjadi saat kita meng-

eksekusi program java yang kita buat. Dengan kata lain, eksepsi akan langsung dapat kita

temukan saat kita mengeksekusi file class.

Subclass-subclass dari RuntimeException yang didefinisikan pada package standar

java.lang, yaitu :

a. AritmaticException , eksepsi yang terjadi saat terjadinya kesalahan pada kondisi

bilangan aritmatika, misalkan terjadinya pembagian dengan nol.

b. IndexOutOfBoundException, eksepsi yang terjadi saat penggunaan nilai index

yang melebihi nilai index yang dimilikinya.

c. NegativeArraySizeException, eksepsi yang terjadi saat kita mendefinisikan

suatu dimensi array dengan nilai negatif.

d. NullPointerException, eksepsi yang terjadi saat pengaksesan suatu objek yang

memiliki variabel null, padahal objek tersebut seharusnya membutuhkan nilai.

e. ArrayStoreException, eksepsi yang terjadi saat penyimpanan suatu objek pada

suatu array yang memiliki tipe yang berbeda.

f. ClassCastException, eksepsi yang terjadi saat mencoba untuk meng-cast suatu

objek yang tidak sesuai dengan tipenya.

g. IllegalArgumentException, eksepsi yang terjadi saat pengiriman type parameter

yang tidak sesuai dengan tipe parameter yang dibutuhkan.

h. SecurityException, eksepsi yang terjadi saat mencoba untuk mengakses

keamanan sistem operasi. Misalkan eksepsi akan terjadi saat suatu applet

mencoba untuk membaca suatu file pada suatu mesin lokal.

i. IllegalMonitorStateException, eksepsi yang terjasi saat suatu thread mencoba

untuk menunggu monitor pada suatu objek yang tidak memiliki thread.

180


j. IllegalStateException, eksepsi yang terjadi saat pemanggilan suatu method yang

tidak diperbolehkan untuk memanggil method.

k. UnsupportedOperationException, eksepsi yang terjadi saat terjadinya

pemanggilan suatu operasi yang tidak disupport.

Untuk memperjelas pemahaman kita tentang RuntimeException, contoh 8.1 memberikan

Contoh 8.1 :

/* * Nama File : MainExcep.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MainExcep { 2 3 public static void main(String[] args){ 4 int a = 0; 5 int b = 26/a; 6 System.out.println("nilainya : " + b); 7 } 8 }


Dari hasil eksekusi contoh 8.1 diperoleh bahwa terjadi eksepsi pada program

MainExcep. Contoh ini juga menunjukkan bahwa saat kita mengeksekusi file class

MainExcep, runtime memberikan kesalahan terjadinya pembagian dengan nol seperti yang

ditunjukkan pada gambar 8.1. Ini menunjukkan bahwa dengan adanya eksepsi ini maka

181


kita tidak dapat mengeksekusi program yang telah kita buat karena runtime java langsung

mematikan aplikasi yang telah kita buat.

Eksepsi dapat juga terjadi pada suatu method di dalam suatu program. Misalkan

pada contoh 8.1 kita mengubah operasi aritematikanya di dalam suatu method seperti

yang ditunjukkan pada contoh 8.2 berikut.

Contoh 8.2 :

/* * Nama File : Fibonaci.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MainExec2 { 2 3 public static void main(String[] args){ 4 System.out.println("nilainya : " ); 5 MainExec2.subroutine(); 6 } 7 static void subroutine(){ 8 int a = 0; 9 int b = 26/a; 10 11 } 12 }


182


Dari hasil eksekusi contoh 8.2 diperoleh bahwa terjadi eksepsi pada suatu method,

yaitu method subroutine. Contoh ini juga menunjukkan bahwa saat kita mengeksekusi

file class MainExec2, runtime memberikan kesalahan terjadinya pembagian dengan nol

pada method subroutine. Ini menunjukkan bahwa dengan adanya eksepsi ini maka kita

tidak dapat mengeksekusi program yang telah kita buat karena runtime java langsung

mematikan aplikasi yang telah kita buat. Jadi pada pemrograman Java akan ditangani

eksepsi yang terjadi baik pada program maupun pada method. Untuk itu kita perlu

menangani eksepsi yang terjadi sehingga aplikasi yang akan kita bangun dapat berjalan

sebagaimana mestinya tanpa terjadinya eksepsi yang menyebakan pemberhentian aplikasi

oleh runtime java. Penanganan eksepsi ini dapat kita lakukan dengan cara try dan catch,

seperti yang akan dijelaskan pada sub bab berikut ini.

8.3 Try dan catch

Salah satu kelebihan bahasa pemrograman java adalah penanganan terhadap

setiap kemungkinan kesalahan yang terjadi pada source code yang kita buat oleh

compiler Java dan kesalahan ini langsung diinformasikan kepada programer sehingga

memudahkan kita di dalam memperbaikan kesalahan. Seperti yang ditunjukkan dari hasil

pengeksekusian file class yang telah kita compile terlihat bahwa pada class MainExec2

menampilkan pesan Exception in thread “main” java.lang.ArithmeticException : / by

zero at MainExec2.subroutine (MainExec2.java :19). Informasi ini diberikan oleh

runtime Java untuk memberikan penjelasan dalam memudahkan bagi programmer, yaitu

bahwa terjadi eksepsi pada baris ke 19 di method subroutine dari class MainExec2 yaitu

terjadi pembagian dengan nol (by zero).

Untuk menangani terjadinya eksepsi, kita menggunakan kata kunci try yang

digunakan untuk menentukan suatu blok program yang harus dijaga terhadap semua

eksepsi, kemudian menggunakan catch yang menentukan tipe eksepsi yang ingin

ditangkap.

Misalkan pada contoh 8.2 diperlihatkan bahwa eksepsi terjadi karena kesalahan pada

ArithmeticException yaitu terjadi pembagian dengan nol, maka dengan menggunakan

catch ArithmeticException , seperti yang ditunjukkan pada contoh 8.3.

183


Contoh 8.3 :

/* * Nama File : MainExec4.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class MainExec4 { 2 3 public static void main(String[] args){ 4 5 System.out.println("nilainya : " ); 6 try{ 7 MainExec2.subroutine(); 8 }catch(ArithmeticException e){ 9 System.out.println("Pembagian dengan nol"); 10 } 11 } 12 13 static void subroutine(){ 14 int a = 0; 15 int b = 26/a; 16 } 17 }

Dengan mengimplementasikan source code contoh 8.3 kita akan memperoleh

hasil pengeksekusian program seperti yang ditunjukkan pada gambar 8.4. Ini

menunjukkan bahwa eksekusi program tetap berjalan tanpa di akhiri oleh runtime java.

Program yang dijalankan memberikan informasi yang lebih dapat dipahami oleh

pengguna yaitu terjadi pembagian dengan nol, yang seakan-akan bagi pengguna tidak

terjadi kesalahan.


184


Jika kita perhatikan hasil eksekusi program tersebut dengan source code yang

telah kita buat di dalam contoh 8.3, memberikan penjelasan kepada kita bahwa saat

method main dieksekusi maka baris 5 akan dieksekusi sehingga menampilkan “ nilaiya :”

kemudian masuk kedalam blok try yang akan mencoba mengeksekusi method

subroutine() yang ada pada baris 7, tetapi saat dalam method subroutine() terjadi

pembagian dengan nol maka blok try akan melempar ke blok catch untuk menangani

kesalahan akibat terjadinya ArithmeticException sehingga blok catch dieksekusi. Saat

mengeksekusi block catch maka runtime java akan mengeksekusi bari 9 sehingga

memberikan informasi "Pembagian dengan nol", sesuai dengan informasi yang kita berikan.

Seperti yang ditunjukkan pada gambar 8.4.

Dari gambar 8.4 terlihat dengan jelas bahwa blok catch digunakan hanya untuk

menangkap eksepsi yang terjadi setelah blok try , sesuai dengan tipe eksepsi yang hendak

ditangkap, yaitu hanya ArithmeticException. Akibatnya, jika terjadi eksepsi yang

disebabkan oleh tipe eksepsi lain diluar ArithmeticException maka pengeksekusian

program juga tidak akan berjalan dengan baik.

Contoh 8.4 :


1 public class MainExec5 { 2 3 public static void main(String[] args){ 4 try{ 5 int a = args.length; 6 int b = 42/a; 7 8 int c[] = {2}; 9 c[1] = 99; 10 System.out.println("nilai c : " + c[0]); 11 }catch(ArithmeticException ep){ 12 System.out.println("Pembagian dengan nol " + ep); 13 14 } 15 System.out.println("nilainya : "); 16 } 17 }

185


Dengan mengimplementasikan source code contoh 8.4 akan diperoleh hasil

eksekusi program seperti yang ditunjukkan pada gambar 8.5. Ini menunjukkan bahwa

eksekusi program tetap berjalan tanpa di akhiri oleh runtime java saat nilai args.length

(panjangnya string masukan) bernilai nol, yaitu saat kita tidak memberikan nilai

parameter masukan. Tetapi saat kita memberikan nilai parameter masuk misalkan 2,

maka nilai args.length akan menjadi 1 yang tidak sama dengan nol. Ini mengakibatkan

bahwa nilai dari b sama dengan 42, yaitu 42/1. Tetapi karena baris 8 yang dieksekusi

yaitu array c yang memiliki indeks satu dengan nilainya 2 dan kemudian aplikasi akan

mengeksekusi baris 9 yang mencoba untuk memasukkan nilai baru pada array c yaitu 99

pada indeks kedua sedangkan panjang index c hanya satu, maka runtime Java akan

menangkap terjadinya eksekusi ArrayIndexOutOfBoundsException. Yaitu eksepsi yang

terjadi akibat penggunaan nilai index yang melebihi nilai index yang dimiliki array c.


Untuk mengatasi permasalahan di atas diperlukan pernyataan catch yang lebih

dari satu yang lebih kita kenal dengan sebutan pernyataan catch majemuk. Seperti yang

akan dijelaskan pada sub bab berikut ini.

186


8.4 Pernyataan Catch Majemuk

Untuk membuat keadaan eksepsional mengisi sejumlah variabel keadaan yang

berarti, lalu melanjutkan eksekusi program seakan tidak pernah terjadi kesalahan

diperlukan catch majemuk. Pada catch majemuk kita membuat sejumlah pernyataan catch

dalam mengatasi satu blok try. Dimana jika suatu blok catch tidak menangani eksepsi,

maka penangannya akan tergantung pada blok catch berikutnya sampai penanganan

runtime java terluar mengambil alih dan mencetak penelusuran tumpukannya.

Misalkan kita menambahkan penanganan eksepsi pada contoh 8.4, yaitu dengan

menambahkan block catch yang kusus menangani eksepsi akibat terjadinya akibat

penggunaan nilai index yang melebihi nilai index yang dimilikinya seperti yang

ditunjukkan pada Contoh 8.5.

Contoh 8.5


1 public class MainExec5 { 2 public static void main(String[] args){ 3 try{ 4 int a = args.length; 5 int b = 42/a; 6 7 int c[] = {2}; 8 c[1] = 99; 9 System.out.println("nilai c : " + c[0]); 10 }catch(ArithmeticException ep){ 11 System.out.println("Pembagian dengan nol " + ep); 12 13 } catch(ArrayIndexOutOfBoundsException err){ 14 System.out.println("Melebihi batas nilai array " + err); 15 } 16 System.out.println("nilainya : "); 17 } 18 }


eksekusi program seperti yang ditunjukkan pada gambar 8.6. Hasil eksekusi ini

187


menunjukkan pada saat terjadi pengisian pada array c yang melebihi kemampuan

menampung array, maka akan ditangkap oleh ArrayIndexOutOfBoundsException,

sedangkan saat terjadi pembagian dengan nol maka eksepsi akan ditangkap oleh

ArithmeticException.


Terkadang kita tidak dapat mengingat semua penanganan eksepsi yang terjadi,

tetapi kita tidak usah takut akan hal itu karena Java telah menyediakan class Throwable

kusus yang dapat kita gunakan untuk menangani eksepsi secara umum seperti yang


Contoh 8.6 :


1 public class MainExec5 { 2 3 public static void main(String[] args){ 4 try{ 5 int a = args.length; 6 int b = 42/a; 7 8 int c[] = {2}; 9 c[1] = 99;

188


10 System.out.println("nilai c : " + c[0]); 11 } catch(Throwabel th){ 12 System.out.println("Eksepsi yang terjadi " + th); 13 } 14 System.out.println("nilainya : "); 15 } 16 }



eksekusi program seperti yang ditunjukkan pada gambar 8.6. Tetapi jenis penanganan

yang seperti ini akan terlalu umum, sehingga kita sedikit susah di dalam mengetahui

operasi yang menyebakan terjadinya tipe eksepsi. Untuk itu sangat disarankan untuk

menggunakan penanganan tipe eksepsi yang lebih kusus seperti yang dibahas pada sub

sebelumnya. Dalam mengatasi hal tipe eksepsi yang terlalu umum dapat kita lakukan

dengan menggunakan class Throwable kemudian saat kita memperoleh informasi jenis

eksepsi yang terjadi kita menambahkan block catch dari eksepsi yang kita peroleh.

8.5 Pernyataan Try Bersusun

Pernyataan try bersusun sangat mirip dengan konsep method bersusun, dimana

setiap method diperuntukkan untuk menyelesaikan suatu operasi tertentu. Pada try

bersusun setiap try akan menangani blok program tertentu yang diikuti oleh catch-nya

masing-masing. Dalam hal ini blok try akan melindungi bagian program tertentu

sedangkan blok try yang lain akan melindungi bagian program yang lain.

189


Dalam pembentukan try bersusun diusahakan untuk membuat blok program terluar

yang tingkat eksepsinya lebih sering terjadi dari pada blok try yang didalam blok try

yang sebelumnya. Bentuk umum pernyataan try bersusun adalah sebagai berikut :

try { block code yang akan dieksekusi try { block code yang akan dieksekusi try { block code yang akan dieksekusi : :

}catch (ExceptionType1 e){ // penanganan eksepsi yang terjadi akibat ExceptionType1

} catch (ExceptionType2 e){ // penanganan eksepsi yang terjadi akibat ExceptionType2 throw(e); // untuk melempar eksepsi yang terjadi

}finally{ }

}catch (ExceptionType1 e){

// penanganan eksepsi yang terjadi akibat ExceptionType1 } catch (ExceptionType2 e){

// penanganan eksepsi yang terjadi akibat ExceptionType2 throw(e); // untuk melempar eksepsi yang terjadi

}finally{ }

}catch (ExceptionType1 e){ // penanganan eksepsi yang terjadi akibat ExceptionType1 } catch (ExceptionType2 e){ // penanganan eksepsi yang terjadi akibat ExceptionType2 throw(e); // untuk melempar eksepsi yang terjadi }finally{ }

Penanganan eksepsi yang diberikan pada contoh 8.5 dapat dibuat dalam bentuk try

bersusun seperti yang ditunjukkan pada contoh 8.7, yang akan menghasilkan eksekusi

yang sama.

Contoh 8.7 : /* * Nama File : MainExecepTryBersusun.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

190


1 public class MainExcepTryBersusun { 2 3 public static void main(String[] args){ 4 try{ 5 int a = args.length; 6 int b = 26/a; 7 8 try{ 9 int c[] = {2}; 10 c[1] = 99; 11 System.out.println("nilai c : " + c[0]); 12 }catch(ArrayIndexOutOfBoundsException e){ 13 System.out.println("index array over flow " + e); 14 } 15 }catch(ArithmeticException e){ 16 System.out.println("Pembagian dengan nol"); 17 18 } 19 System.out.println("nilainya : "); 20 } 21 }

Dari contoh 8.7 akan kita dapatkan informasi bahwa saat terjadinya eksepsi

pembagian dengan nol, yaitu saat baris 6 sampai 14 tidak akan pernah dieksekusi. Tetapi

jika baris 6 tidak terjadi eksepsi maka baris 8 sampai 14 akan dieksekusi sehingga akan

menghemat waktu pengeksekusian program. Ini menunjukkan bahwa try bersusun lebih

efektif digunakan untuk menangani kasus operasi yang berantai, yaitu operasi yang

terjadi dengan nilai parameter yang diperlukan tergantung dari hasil operasi sebelumnya.

Karena jika operasi sebelumnya menghasilkan eksepsi maka operasi yang dibawahnya

tidak akan pernah dieksekusi. Untuk memberikan pemahaman yang lebih jelas tentang try

bersusun perhatikan contoh 8.8.

Contoh 8.8 :

/* * Nama File TryBersusun.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class TryBersusun { 2 public static void main(String[] args){ 3 4 try{ 5 int a = args.length;

191


6 int b = 6/a; 7 8 try{ 9 int c[] = new int[b]; 10 11 c[0] = 2; 12 c[4] = 99; 13 14 System.out.println("nilai c[4] : " + c[4]); 15 }catch (ArrayIndexOutOfBoundsException err){ 16 System.out.println("Melebihi batas nilai array " + err); 17 } 18 19 System.out.println("nilai b : " + b); 20 }catch(ArithmeticException ep){ 21 System.out.println("Pembagian dengan nol " + ep); 22 } 23 System.out.println("nilainya : "); 24 } 25 }


Dari hasil eksekusi program pada contoh 8.8 menghahsilkan seperti yang

ditunjukkan pada gambar 8.8. Hal ini memberikan informasi kepada kita bahwa saat

panjang args bernilai nol, maka akan terjadi eksepsi pada baris 6 sehingga eksepsi akan

dilempar ke baris 20 yang mengakibatkan baris di bawah baris 6 tidak akan dieksekusi.

Jika nilai args kita berikan dengan panjang dua, maka nilai a akan bernilai 2, yang

mengakibatkan nilai b adalah 3. Sehingga block try pertama tidak akan menemukan

args.length = 0 Terjadi pebagian nol

args.length = 2 maka b = 3 (6/2)

args.length = 1 maka b = 6 (6/1)

192


terjadinya eksepsi, tetapi pada baris 13 akan ditemukan eksepsi sehingga blok try akan

melempar eksepsi untuk ditangkap block catch pada baris ke 15. Jika nilai args kita

berikan dengan panjang satu, maka nilai a akan bernilai 1, yang mengakibatkan nilai b

adalah 6. Sehingga block try pertama tidak akan menemukan terjadinya eksepsi,

kemudian dalam block try berikutnya juga tidak akan ditemukan eksepsi, karena nilai

indeks dari array c adalah 6.

8.6 Pernyataan throw

Pernyataan throw digunakan untuk melemparkan suatu eksepsi secara eksplisit.

Dalam penanganan eksepsi dengan throw terlebih dahulu kita memanggil instan

Throwable dengan menambahkan operator new setelah instan dari Throwable. Bentuk

umum dari pernyataan throw adalah sebagai berikut :

throw new ThrowableInstance ;

Untuk memberikan pemahaman yang lebih jelas mengenai penggunaan throw dapat kita

lihat pada contoh 8.9.

Contoh 8.9 :

/* * Nama File : ThrowExec.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class ThrowExec { 2 3 public static void main(String[] args){ 4 5 int inpA = args.length; 6 System.out.println("panjang string : " + inpA); 7 subroutine(inpA); } 8 9 static void subroutine(int inA){ 10 try{ 11 int a = inA; 12 int b = 26/a; 13 System.out.println("dalam subroutine"); 14 throw new IllegalAccessException ("test"); 15 }catch(IllegalAccessException e){

193


16 System.out.println(e); 17 } 18 } 19 }

Hasil dari eksekusi program contoh 8.9 akan diperoleh seperti yang ditunjukkan

pada gambar 8.9. Hal ini memberikan informasi kepada kita bahwa saat panjang args

bernilai satu, maka tidak terjadi eksepsi pada baris 12 karena nila a diperoleh dari passing

parameter yang dilakukan terhadap method subroutine(int inA) yaitu bernilai 1 maka

block catch tidak akan menangkap terjadinya eksepsi kemudian akan mengeksekusi baris

13 dan baris 14. Pada baris 14 kita membuat objek IllegalAccessException dengan nama

test yang akan ditangkap oleh block catch sehingga eksepsi akan dilempar ke baris 15

dan eksepsi yang ditangkap akan ditampilkan dengan menggunakan attribut e pada baris

16. Jika nilai panjang args bernilai nol, maka baris 12 akan menemukan pembagian

dengan nol yang akan dilempar ke block catch. Perlu diperhatikan bahwa setelah

pernyataan throw dalam suatu blok method tidak boleh memambahkan statement lain.


args.length= 1

args.length= 0

194


8.7 Pernyataan throws

Pernyataan throws digunakan untuk menangani eksepsi yang terjadi pada suatu

method tertentu. Kata kunci throws digunakan untuk mengidentifikasi daftar eksepsi

yang mungkin di lempar oleh suatu method. Bentuk umum dari pernyataan throws

adalah sebagai berikut :

type method-name throws Exception-list { block code yang akan dieksekusi throw new ThrowableInstance ;

}

Perlu diperhatikan perbedaan antara pernyataan throw dengan throws di dalam

melemparkan eksepsi yang terjadi di Java. Pernyataan throws digunakan jika kita hendak

menangani terjadinya eksepsi pada suatu block method yang akan ditangkap oleh throw,

dengan kata lain dalam pernyataan throws kita tidak perlu harus membuat try-catch.

Tetapi dalam method yang akan menangani method yang di-throws kita harus memblok

method dengan try-catch. Sedangkan pernyataan throw digunakan untuk melempar

terjadinya eksepsi di dalam suatu method. Untuk memberikan pemahaman yang lebih

jelas mengenai penggunaan throws dapat kita lihat pada contoh 8.10.

Contoh 8.10 :

1 /* 2 * Nama File : ThrowsExec.java 3 * Programmer : @ author Jasman Pardede 4 * Deskripsi : Program sederhana Java 5 * @version 1.1 6 */

7

8 public class ThrowsExec { 9 10 public static void main(String[] args){ 11 12 System.out.println("nilainya : " ); 13 try{ 14 int inpA = args.length; 15 System.out.println("panjang string : " + inpA); 16 subroutine(inpA); 17 }catch(IllegalAccessException e){ 18 System.out.println(e); 19 } 20 }

195


21 22 static void subroutine(int inA) throws IllegalAccessException { 23 try{ 24 int a = inA; 25 int b = 42/a; 26 27 System.out.println("dalam subroutine"); 28 throw new IllegalAccessException ("test"); 29 }catch(IllegalAccessException e){ 30 System.out.println(e); 31 } 32 } 33 }


Ketika kita running ThowsExec contoh 8.10 dengan memberikan nilai args[0] sama

dengan 23, maka panjang list args adalah 1. Akibatnya nilai inpA sama dengan 14, yang

diperoleh dengan menggunakan method length. Pada baris ke 16 mengeksekusi

subroutine(inpA), sehingga akan memanggil method subroutine(int inA) throws

IllegalAccessException pada baris 22. Karena pada baris 28 pada blok subroutine kita

melakukan throw ke IllegalAccessException, yang akan di tangkap pada baris 29 maka

akan mengeksekusi baris 30. Ini menunjukkan bahwa saat di dalam blok method kita

membuat suatu thow makan akan dipaksa untuk dilemparkan ke eksepsi yang kita thow,

kemudian akan ditangkap oleh catch yang bersesuaian dengan jenis eksepsi yang kita

196


lempar. Sedangkan saat kita memberikan nilai args[ ] dengan nilai kosong, maka panjang

list args adalah 0, akibatnya saat baris 16 dieksekusi akan memanggil subrutin baris 22.

Pada blok method subrutin tersebut terjadi pembagian dengan nol, yaitu saat dieksekusi

baris 25 telah terjadi pembagian dengan nol, dimana nilai a diperoleh dari panjang list

agrs. Eksepsi yang terjadi pada subrutin akan ditangkan oleh IllegalAccessException pada

baris 17. Adapun hasil eksekusi source code contoh 8.10 di atas akan diperoleh seperti

yang ditampilkan pada gambar 8.10. Pada bagian pertama dengan memberikan nilai

argumen 23 dan bagian kedua dengan memberikan nilai argumen kosong.

8.8 Pernyataan finally

Pernyataan finally digunakan untuk menangani terjadinya eksepsi dengan cara

mengakhiri eksekusi program dengan cara yang normal karena saat bagian finally

dieksekusi maka runtime java akan menutup penanganan file dan membebaskan sejumlah

sumber lainnya yang mungkin telah dialokasikan di awal program. Bagian finally

sepenuhnya bersifat pilihan yang dapat kita gantikan dengan pernyataan try-catch yang

tidak membutuhkan jaminan keadaan setelahnya. Saat kita menangani eksepsi dengan

memasukkan kata kunci finally maka kode di dalam block finally akan selalu dieksekusi

tidak peduli eksepsi apapun yang terjadi dan ditangkap.

Penggunaan kata kunci finally sangat diharapkan dalam penanganan eksepsi yang

membutuhan pembebasan sejumlah sumber dan penutupan program saat terjadi eksepsi.

Untuk memberi pemahanan yang lebih jelas tentang penggunaan finally dapat kita

perhatikan contoh 8.11 yang diberikan.

Contoh 8.11 :

/* * Nama File : TryFinal.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 public class TryFinal { 2 3 public static void main(String[] args){ 4

197


5 System.out.println("nilainya : " ); 6 try{ 7 int inpA = args.length; 8 subroutine(inpA); 9 } 10 finally{ 11 System.out.println("Diluar catch yang tidak diketahui"); 12 } 13 } 14 15 static void subroutine(int inA){ 16 17 try{ 18 int a = inA; 19 int b = 42/a; 20 }catch(ArithmeticException e){ 21 throw e; 22 } 23 24 }

Hasil dari eksekusi program diatas akan diperoleh seperti yang ditunjukkan pada gambar

8.9. Ini menunjukkan bahwa block finally akan selalu dieksekusi walaupun tidak terjadi

eksepsi. Karena pada baris 18 nilai dari a adalah satu sehingga tidak terjadi eksepsi tetapi

block finally tetap juga dieksekusi. Saat mengeksekusi block finally runtime Java akan

melepaskan semua sumber yang dimiliki oleh program. Pada contoh 8.10 saat kita

mengeksekusi java TryFinal 2 maka parameter inpA akan dialokasikan untuk memegan

nilai 1 tetapi saat finally dieksekusi maka alokasi sumber untuk memegan nilai 1 akan

dibebaskan sebelum program ditutup. Sedangkan jika kita mengeksekusi program tanpa

argumen maka nilai inpA adalah nol maka hasil passing parameter pada baris 18 adalah

nol, akibatnya pada baris 19 akan mengakibatkan terjadinya eksepsi yaitu terjadi

pembagian dengan nol. Eksepsi yang terjadi pada baris 19 akan ditangkap oleh block

catch sedangkan block finally akan tetap dieksekusi.

198



8.9 Subclass Eksepsi

Eksepsi yang terjadi tidak selalu merupakan eksepsi dari subclass Throwable.

Misalkan dalam program yang akan kita bangun tidak memperbolehkan data yang bertipe

int maka subclass Throwable tidak akan akan dapat menangkap terjadinya eksepsi. Jika

hal ini terjadi maka akan mengakibatkan program tidak akan berjalan dengan baik. Untuk

mengatasi hal seperti ini kita harus membuat objek baru yang mampu menangani tipe

eksepsi kita sendiri dengan cara membuat subclass dari Exception.

Bentuk umum dalam pembuatan subclass Exception kita cukup menggunakan

kata kunci extends Exception, seperti yang ditunjukkan berikut ini.

Class namaClassException extends Exception {

Informsi yang diberikan kepada pengguna eksepsi

}

Untuk memberi pemahanan yang lebih jelas tentang pembuatan subclass eksepsi

dapat kita perhatikan contoh 8.12.

Contoh 8.12 :

/* * Nama File : MyException.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

199


1 public class MyException extends Exception{ 2 private int value; 3 private String cmd; 4 5 public MyException(int myValue){ 6 value = myValue; 7 } 8 9 public String toString(){ 10 if(value >5) 11 return "Data yang Anda masukkan melebihi nilai [" + value + "]"; 12 else 13 return "Anda tidak memasukkan operand"; 14 15 } 16 17 public MyException(String myCmd){ 18 cmd = myCmd; 19 } 20 }

Contoh 8.13 :

/* * Nama File : MainMyExcep.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.io.*; 2 import java.util.*; 3 4 public class MainMyExcep{ 5 6 public static void main(String[] args){ 7 String cmdX; 8 int x; 9 10 BufferedReader inputUser = new BufferedReader(new 11 InputStreamReader(System.in)); 12 13 try{ 14 System.out.println("Pilih Angka : "); 15 cmdX = inputUser.readLine(); 16 checkData(cmdX); 17 x = (int)Integer.parseInt(cmdX); 18 checkData(x); 19 System.out.println("Anda mengikuti aturan");

200


20 } 21 catch(MyException e){ 22 System.out.println(e); 23 } 24 catch(IOException e){ 25 return; 26 } 27 } 28 static void checkData(int value) throws MyException{ 29 if(value>5) 30 throw new MyException(value); 31 } 32 33 static void checkData(String cmd) throws MyException{ 34 if(cmd.length() ==0) 35 throw new MyException(cmd); 36 } 37 }

Gambar 8.12 Hasil eksekusi contoh 8.12 dengan driver contoh 8.13

Saat kita mengeksekusi driver contoh eksepsi yang kita buat pada contoh 8.12

maka kita akan mendapatkan hasil seperti yang ditunjukkan pada gambar 8.12. Pada hasil

eksekusi terlihat jika pada saat nilai Pilih Angka : tidak memberikan suatu memasukkan

dari keyboard maka program akan menemukan kesalahan. Hal ini di cek oleh method

checkData pada baris 16, yang akan dieksekusi pada baris 33 dimana setiap masukan dari

keyboard selalu dimasukkan tipe string. Saat baris 34 mengetahui bahwa panjang string

masukan bernilai nol, maka akan dilemparkan oleh objek eksepsi yang kita buat.

String kosong, eksepsi baris 33

String 7, eksepsi baris 29

String 4,tidak ada eksepsi baris

201


Akibatnya akan mengeksekusi program contoh 8.12 yang akan memberikan informasi

pada baris 13. Jika nilai Pilih Angka : nilai yang lebih besar dari 5 pada contoh ini nilai 7

maka method checkData pada contoh 8.13 baris 16 tidak akan menemukan eksepsi,

sehingga nilai string dapat diparsing ke nilai bertipe int . Tetapi pada baris 18 contoh 8.13

akan melakukan pengecheckan nilai masukan yang akan dikirimkan ke method

checkData baris 28. Saat baris 29 dieksekusi ditemukan eksepsi yang dilempar ke objek

myException yang kita buat sehingga akan mengeksekusi program contoh 8.12 yang

akan memberikan informasi pada baris 11. Pada kasus yang ketiga, saat nilai masukan

yang diberikan nilai 4 maka tidak akan ditemukan eksepsi, sehingga dieksekusi sampai

akhir program.

202


Soal Latihan Bab 8. 1. Apa yang dimaksude dengan eksepsi.

2. Jelaskan bentuk umum dari suatu eksepsi.

3. Jelaskan perbedaan antara thow dan thows.

4. Apa yang dimaksud dengan finally pada blok eksepsi dan berikan contoh

penggunaannya.

5. Buatlah class eksepsi bentukan,untuk menangkap memasukkan pengguna. Masukkan

pengguna dengan suatu String “aman” akan dilempar sebagai eksepsi dengan informasi

“Terjadi mata-mata, pengguna memasukkan kata aman”.

203


Bab 9 Thread

Dalam sebuah pemrograman berorientasi object seperti halnya Program Java, kita

mengenal sebuah pengontrol aliran program yang akan dieksekusi oleh komputer

(Threads). Dengan adanya threads dalam pemrograman java kita dapat membuat program

yang saling berurutan (sekuensial). Pada bab ini kita akan membahas thread pada Java di

dalam menangani proses yang berjalan secara bersamaan.

9.1 Thread pada Java

Thread merupakan kemampuan yang disediakan oleh Java untuk membuat

aplikasi yang tangguh, karena thread dalam program memiliki fungsi dan tugas tersendiri.

Dengan adanya thread, dapat membuat program yang lebih efisien dalam hal kecepatan

maupun penggunaan sumber daya, karena kita dapat membagi proses dalam aplikasi kita

pada waktu yang sama. Thread umumnya digunakan untuk pemrograman multitasking,

networking, yang melibatkan pengaksesan ke sumber daya secara konkuren.

Thread pada Java diciptakan dan dikelola melalui kelas Thread yang terdapat di

package standar java .lang . Pada Java, menciptakan suatu objek kelas Thread akan

menciptakan suatu thread .

Kelas Thread di Java menyediakan sejumlah metode untuk mengendalikan thread

misalnya untuk memasuki antrian (start), istirahat (sleep), dan lain-lain. Metode dari

kelas Thread yang harus didefinisikan kembali oleh sub kelas adalah metode run .

Metode run akan dipanggil secara otomatis saat suatu thread memegang kendali

pemroses. Selain kelas Thread , Java juga menyediakan interface Runnable yang dapat

diimplementasikan oleh kelas yang mengimplentasikan metode run .

Setiap thread yang diciptakan pada Java memiliki memori kerja (working

memory) yang digunakan untuk menyimpan copy dari variabel-variabel yang digunakan.

Ketika suatu thread mengeksekusi program Java, thread melakukan operasi pada memori

kerja tersebut, sementara memori utama digunakan sebagai master copy. Terdapat aturan-

aturan pada implementasi tingkat rendah (low level) yang digunakan untuk mengatur

pemutakhiran dari memori kerja ke memori utama dan sebaliknya.

204


Setiap thread memiliki prioritas yang menentukan penjadwalan thread. Bila

thread diciptakan tanpa mendefinisikan prioritas secara eksplisit maka akan digunakan

prioritas default, yaitu mempunyai nilai prioritas lima. Bila terdapat suatu thread yang

memiliki prioritas yang lebih tinggi dari thread yang lain maka thread tersebut akan

segera dijalankan sedangkan thread yang sebelumnya sedang berjalam akan segera

menuju antrian (preemptive).

Gambar 9.1 Status thread

Dengan mendefinisikan atribut modifier sebagai volatile akan dijamin bahwa

setiap akses ke atribut tersebut yang akan dilakukan oleh suatu thread dijamin akan

mengakses nilai current pada memori utama. Tiap thread selalu memiliki satu dari lima

status seperti yang ditunjukkan pada gambar 9.1.

Lima status tersebut adalah sebagai berikut :

1. Newborn, yaitu status yang dimiliki suatu thread yang baru diciptakan namun belum

dijalankan. Alokasi memori telah diberikan dan data private telah diinisialasi namun

thread belum terjadwal. Pada titik ini, thread dapat masuk antrian melalui metode

start atau dihancurkan dengan metode stop. Bila thread masuk antrian selanjutnya

thread memasuki status runnable.

2. Runnable, yaitu thread yang telah masuk jadwal dan menunggu kendali dari

pemroses. Bila semua thread di dalam antrian memiliki prioritas yang sama akan

berlaku FIFO. Bila thread melepaskan kendali pemroses dan masih perlu untuk

205


proses berikutnya maka thread tersebut akan menuju akhir antrian. Bila terdapat

thread dengan prioritas yang lebih tinggi dari semua thread yang ada di antrian

selanjutnya thread tersebut akan berada di depan antrian. Bila thread yang datang

memiliki prioritas lebih tinggi dari thread yang sedang memegang kendali akan

dipaksa melepaskan kendali (preempt) dan menuju ke akhir antrian.

3. Running, yaitu thread yang sedang memegang kendali pemroses dan melaksanakan

eksekusi hingga dipaksa melepaskan kendali oleh thread yang lebih tinggi

prioritasnya atau hingga thread melepaskan sendiri kendali yang dimiliki. Suatu

thread mungkin melepaskan sendiri kendali karena satu dari tiga hal berikut :

a) Thread dengan sengaja melepaskan kendali (yield) untuk memberikan

kesempatan kepada thread lain memperoleh kendali pemroses.

b) Thread istirahat (sleep) untuk waktu tertentu. Setelah waktu habis thread masuk

ke antrian.

c) Thread menunggu (wait) suatu kejadian yang diberitahu (notify) oleh thread

lain agar selanjutnya thread mengakhiri blok dan kembali memasuki antrian.

4. Blocked, yaitu thread sedang terblok (blocked) yang berarti mencegah thread

tersebut untuk memasuki antrian. Thread yang istirahat (sleep) akan terblok hingga

sejumlah waktu tertentu. Thread yang bertahan (suspend) akan terblok hingga ada

permintaan untuk meneruskan (resume). Thread yang menunggu (wait) akan terblok

hingga diberitahu (notify) suatu event dari thread lain.

5. Dead, yaitu thread yang selesai eksekusi, baik karena permintaan thread sendiri atau

dihentikan (stop) oleh thread yang lain. Thread selanjutnya akan dihancurkan.

9.2 Sinkonisasi Proses pada Java : Monitor

Java menyediakan mekanisme untuk sinkronisasi aktivitas konkuren banyak

thread melalui monitor. Monitor merupakan konstruksi bahasa tingkat tinggi yang

memungkinkan hanya satu thread pada satu saat yang dapat mengeksekusi satu blok

kode yang diproteksi oleh monitor. Java mengadaptasikan monitor dari C.A.R. Hoare

yang merupakan properti utama yang digunakan untuk mencapai kondisi mutual

exclusion.

206


Kelakuan monitor pada java dijelaskan melalui terminologi lock yaitu hanya ada

satu lock yang berasosiasi dengan satu objek Java. Kondisi mutual exclusion dapat

dicapai bila satu thread yang akan mengeksekusi satu blok kode harus terlebih dahulu

mengunci lock dari objek yang memiliki metode tersebut. Bila lock berhasil dikunci

selanjutnya thread tersebut dapat mengeksekusi blok kode dengan jaminan mutual

exclusion atau dengan kata lain thread tersebut memasuki monitor. Bila lock gagal

dikunci karena thread lain telah mengunci lock, maka thread tersebut harus menungu

thread lain yang mendahului agar melepaskan lock atau dengan kata lain menunggu

thread lain meninggalkan monitor.

Mekanisme monitor pada Java juga menyediakan cara bagi suatu thread untuk

terblok bila thread tersebut tidak dapat melanjutkan eksekusi. Thread yang terblok

selanjutnya dapat dibangunkan untuk melanjutkan eksekusi. Hal tersebut khususnya

sesuai untuk situasi seperti pada relasi producer-consumer. Setiap objek pada Java

memiliki satu penampung yang menyimpan informasi tentang sejumlah thread yang

sedang terblok pada objek tersebut. Pustaka kelas Java menyediakan metode wait ,

notify , notifyAll yang merupakan anggota dari root kelas objek untuk mekanisme

WAIT dan SIGNAL pada konsep monitor C.A.R Hoare. Bila satu thread mengeksekusi

metode wait maka selanjutnya thread tersebut terblok pada objek di mana metode

dieksekusi. Setelah thread terblok, selanjutnya semua lock yang telah dikunci oleh thread

tersebut dilepaskan. Thread yang terblok pada satu objek dapat digunakan oleh thread

lain melalui pemanggilan metode notify pada objek tersebut dengan syarat sebelumnya

telah berhasil mengunci lock dari objek.

9.3 Pemrograman Multithreading pada Java

Untuk mendukung multithreading pada Java, sebuah thread mulai dibuat, ketika

dilakukan pembuatan objek baru, dimana objek tersebut merupakan intance dari sebuah

kelas yang diterapkan dari antarmuka java.lang.Runnable atau diturunkan dari kelas

java.lang.Thread.

Untuk menerapkan pemrograman multithreading dengan Java, kita dapat

melakukannya dengan dua teknik umum, yaitu dengan mendefinisikan sebuah kelas yang

207


menerapkan interface java,lang.Runnable atau mendefisikan sebuah kelas yang

diturunkan dari kelas java.lang.Thread.

9.3.1 Dengan Menerapkan java.lang.Runnable

1. Untuk membuat sebuah kelas yang akan bertindak sebagai sebuah thread,

didefinisikan dengan sintak berikut :

class NamaClass implements Runnable{

void run(){

// kode program yg dikerjakan

}

}

2. Setelah didefinisikan sebuah kelas dengan bentuk umum, berikut adalah cara

memanggil class thread tersebut :

a. Buat instance objek dari kelas Runnable

b. Buat objek dari class java.lang.Thread dengan parameter konstruktor

objek dari kelas Runnable

c. Panggil method start() dari objek Runnable.

9.3.2 Dengan Menurunkan dari kelas java.lang.Thread

Kelas java.lang.Thread sebenarnya merupakan kelas yang juga telah menerapkan

interface Runnable, sehingga kita dapat memanfaatkan kelas Thread ini untuk

menjadikan kelas kita dapat dijalankan oleh sebuah thread.

9.4 Pengontrolan Eksekusi Thread pada Java

Sebuah eksekusi thread dapat dikontrol oleh program atau proses induknya.

Sebuah thread dapat dikontrol untuk mulai dijalankan, atau diberhentikan eksekusinya

dan dapat dijalankan kembali, atau juga dapat dihentikan sesaat berdasarkan lamanya

waktu yang diinginkan. Beberapa method yang dapat dicoba untuk mengontrol eksekusi

thread :

Method start()

Method stop()

208


Kedua method ini hanya dapat dipanggil sekali untuk semua thread yang akan

dikontrol. Method start() akan digunakan untuk memulai eksekusi sebuah thread.

Sedangkan method stop() digunakan untuk menghentikan eksekusi dari sebuah thread

yang sedang berjalan.

Method suspend()

Method resume()

Kedua method ini digunakan untuk menghentikan sementara waktu, yaitu dengan

menggunakan metode suspend(), untuk kemudian dapat dilanjutkan kembali dengan

memanggil method resume().

Method static sleep(int milisecond)

Method ini digunakan untuk menghentikan thread yang aktif selama n milidetik.

Misalkan,

try{ Thread.sleep(1000);

}catch(InterruptedException e){ }

method ini akan menghentikan eksekusi selama 1 detik.

Contoh 9.1 : /* * Nama File : MyThread.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class MyThread implements Runnable{ 2 3 private int countDown = 5; 4 private static int threadCount = 0; 5 private int threadNumber = ++threadCount; 6 7 public MyThread(){ 8 System.out.println("Pembuatan Thread ke " + threadNumber); 9 } 10 11 public void run(){ 12 while(true){ 13 System.out.println("Thread " + threadNumber + "(" + countDown + ")");

209


14 System.out.println("Hello"); 15 16 if(--countDown == 0) 17 return; 18 } 19 } 20 }

Contoh 9.2 : /* * Nama File : MainMyThread.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class MainMyThread{ 2 3 public static void main(String[] args){ 4 for(int i=0; i<3; i++){ 5 MyThread o = new MyThread(); 6 Thread oThread = new Thread(o); 7 8 oThread.start(); 9 } 10 11 System.out.println("Semua Thread telah dibuat"); 12 } 13 14 }

Pada contoh 9.1 kita membuat suatu class MyThread yang mengimplement interface

Runnable seperti yang dinyatakan pada baris 1. Saat kita hendak menjalankan suatu blok

atau proses secara bersamaan, maka proses tersebut kita masukkan ke dalam suatu

method run seperti yang dinyatakan pada 11. Baris 11 contoh 9.1 merupakan method

yang tidak diperolehkan diubah dalam cara penulisannya, karena interpreter java akan

mengeksekusi method tersebut saat method start( ) dipanggil. Blok method baris 11 akan

terus menerus dieksekusi sampai kondisi baris 16 bernilai salah. Karena proses

pengeksekusian suatu thread berdasarkan satu-satu instruksi maka di dalam

pengesekusian blok method run, saat mengeksekusi baris 13 tidak serta merta langsung

mengeksekusi baris 14. Ini tergantung kepada thread yang mana yang memengang

sumber daya. Untuk mengeksekusi contoh 9.1 kita menggunakan contoh 9.2. Karena

210


contoh 9.1 menggunakan implements Runnable maka proses menjalankan tiga proses

secara bersamaan seperti yang dinyatakan perulangan for baris 14 contoh 9.2. Pada baris

5 kita menciptakan objek yang mengimplement Runnable, kemudian kita buatkan objek

Thread seperti yang dinyatakan pada baris 6 dengan argumen yang diberikan adalah

objek yang telah kita cipatakan sebelumnya. Kemudian objek thread tersebut kita

jalankan dengan menggunakan method start( ) seperti yang dinyatakan pada baris 8.

Hasil dari proses eksekusi thread yang kita ciptakan tidak dapat kita tentukan secara pasti.

Pada hasil eksekusi yang diperoleh saat ini adalah, saat thread telah diciptakan maka

eksekusi berikutnya adalah menampilkan informasi yang terdapat pada method run

contoh 9.1, kemudian menciptakan thread 2 dan thread 3, kemudian mengeksekusi baris

11 contoh 9.2. Ini berarti method yang terdapat pada blok run pada contoh 9.1 tidak

langsung dieksekusi baik thread 2 maupun thread 3 tetapi langsung mengeksekusi

instruksi yang terdapat pada baris 11 contoh. Tetapi jika eksekusi contoh 9.2 kembali

maka hasil eksekusinya belum tentu mendapatkan nilai informasi yang sama. Adapun

hasil eksekusi dari listing program contoh 9.2 adalah seperti yang ditunjukkan pada

gambar 9.2.


211


Contoh 9.3 : /* * Nama File : MyThread2.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class MyThread2 extends Thread{ 2 3 private int countDown = 5; 4 private static int threadCount = 0; 5 private int threadNumber = ++threadCount; 6 7 public MyThread2(){ 8 System.out.println("Pembuatan Thread ke " + threadNumber); 9 } 10 11 public void run(){ 12 while(true){ 13 System.out.println("Thread " + threadNumber + "(" + countDown + ")"); 14 15 if(--countDown == 0) 16 return; 17 } 18 } 19 }

Contoh 9.4: /* * Nama File : MainMyThread2.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class MainMyThread2{ 2 3 public static void main(String[] args){ 4 for(int i=0; i<3; i++){ 5 new MyThread2().start(); 6 } 7 8 System.out.println("Semua Thread telah dibuat"); 9 } 10 11 }

212


Pada contoh 9.3 dan contoh 9.4 merupakan pembuatan aplikasi thread yang sama dengan

contoh 9.1 dan contoh 9.2. Pada contoh 9.3 dalam pembuatan aplikasi thread kita meng-

ekstend class Thread, sedangkan proses yang terdapat pada blok run adalah sama dengan

conoth 9.1. Karena kita menggunakan extends Thread maka di dalam pengeksekusian

aplikasi thread yang kita buat sedikit berbeda dengan implements Runnable, seperti yang

dinyatakan pada baris 5. Adapun hasil eksekusi dari listing program contoh 9.3 dan 9.4

adalah seperti yang ditunjukkan pada gambar 9.2.


Contoh 9.5 : /* * Nama File : A.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class A{ 2 synchronized void foo(B b){ 3 String name = Thread.currentThread().getName(); 4 System.out.println(name + " entered A.foo"); 5 6 try{ 7 Thread.sleep(1000); 8 } catch (Exception e){ 9 System.out.println(e); 10 } 11 System.out.println(name + " trying to call B.last() ");

213


12 b.last(); 13 } 14 15 synchronized void last(){ 16 System.out.println("inside A.last"); 17 } 18 19 }

Contoh 9.6 : /* * Nama File B.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class B{ 2 synchronized void bar(A a){ 3 String name = Thread.currentThread().getName(); 4 System.out.println(name + " entered B.bar"); 5 6 try { 7 Thread.sleep(3000); 8 } catch (Exception e){ 9 System.out.println(e); 10 } 11 System.out.println(name + " trying to call A.la st() "); 12 a.last(); 13 } 14 15 synchronized void last(){ 16 System.out.println("inside B.last"); 17 } 18 }

Contoh 9.7 : /* * Nama File : Deadlock.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 public class Deadlock implements Runnable{ 2 A a = new A(); 3 B b = new B(); 4 5 Deadlock(){ 6 Thread.currentThread().setName("MainThread"); 7 new Thread(this, "RacingThread").start(); 8 a.foo(b); 9 System.out.println("back in main thread"); 10 } 11

214


12 public void run(){ 13 b.bar(a); 14 System.out.println("back in other thread"); 15 } 16 17 public static void main(String args[]){ 18 new Deadlock(); 19 } 20 }


Pada contoh 9.7 saat baris 18 dieksekusi akan memanggil method Deadlock yang

terdapat pada baris 5. Pada baris 7 contoh 9.7 objek Deadclok dijalankan dengan

memanggil method start( ), akibatnya akan mengeksekusi method run( ) baris 12. Pada

baris 13 objek b memanggil method bar dengan argument yang dibutuhkan adalah objek

a, maka akan menunggu sumber daya a. Pada baris 8 kita memanggil method foo(b) yang

dimiliki oleh objek a dengan nilai argumenent objek b akibatnya akan memenggil

method foo baris 2 contoh 9.5 yang sudah disinkronkan, kemudian akan mengambil nama

thread pada baris ke 3 dan menampilkan informasinya ke pengguna pada baris 4. Pada

baris 7 objek a akan berhenti selama 1 detik. Setalah habis 1 detik, maka akan

mengeksekusi baris 11 contoh 9.5. Karena baris 12 objek a memangil objek b untuk

mengeksekusi method last() yang dimilikinya maka objek a akan menunggu hasil

eksekusi dari objek b. Karena objek a membutuhkan hasil eksekusi dari objek b dan

objek b tidak dapat melanjutkan eksekusi karena membutuhkan objek a akibatnya kedua

objek saling membutuhkan sumber daya, yang mengakitbatkan terjadinya Deadclok.

215


Adapun hasil eksekusi dari listing program contoh 9.5 adalah seperti yang ditunjukkan

pada gambar 9.4.

Contoh 9.6 : /* * Nama File : JumblesName.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.io.*; 2 public class JumblesName implements Runnable{ 3 4 private String firstName; 5 private String lastName; 6 private long aWhile; 7 8 9 public JumblesName(String firstName, String lastName, long delay){ 10 this.firstName = firstName; 11 this.lastName = lastName; 12 this.aWhile = delay; 13 } 14 15 public void run(){ 16 try{ 17 while(true){ 18 System.out.println(firstName); 19 Thread.sleep(aWhile); 20 System.out.println(lastName + "\n"); 21 } 22 } 23 catch(InterruptedException e){ 24 System.out.println(firstName + " " + lastName + " " + e); 25 } 26 } 27 28 public static void main(String[] args){ 29 Thread jn1 = new Thread(new JumblesName("Erwin", "Cosasi", 1000),"FirstJumble"); 30 Thread jn2 = new Thread(new JumblesName("Mohammad", "Taswin", 3000), 31 "SecondJumble"); 32 Thread jn3 = new Thread(new JumblesName("Hendra", "Bunyamin", 6000), 33 "ThirdJumble"); 34 Thread jn4 = new Thread(new JumblesName("Eka", "Hadi",8000),"FourthJumble"); 35 36 //jn1.setPriority(Thread.MIN_PRIORITY); 37 jn1.setDaemon(true); 38 // setDaemon(true) untuk mereseponi event enter dalam mengakhiri eksekusi

216


39 jn2.setDaemon(true); 40 jn3.setDaemon(true); 41 jn4.setDaemon(true); 42 43 System.out.println("Tekan enter untuk mengakhiri ...."); 44 jn1.start(); 45 jn2.start(); 46 jn3.start(); 47 jn4.start(); 48 try{ 49 System.in.read(); 50 System.out.println("Tekan Enter ..."); 51 } 52 catch(IOException e){ 53 System.out.println("Akhir main() ... "); 54 return; 55 } 56 } 57 58 }


Pada bris 29 samapai 34 kita menciptakan empat buah objek thread dengan setiap objek

memiliki waktu sleep yang berbeda-beda, yang masing-masing akan kita jalankan seperti

yang dinyatakan pada baris 44 smapai 47. Saat setiap objek thread dijalankan maka akan

217


memenggil method run yang terdapat pada baris 15. Karena objek jn1 waktu sleep-nya

lebih kecil dari pada objek yang lain, maka objek jn1 akan lebih sering dieksekusi. Ini

menunjukkan saat terdapat objek jn1 pada antrian yang siap dieksekusi maka objek jn1

yang terlebih dahulu untuk dieksekusi sesuai dengan prioritasnya yang lebih tinggi.

Adapun hasil eksekusi dari listing program contoh 9.7 adalah seperti yang ditunjukkan

pada gambar 9.5.

Contoh 9.7 : /* * Nama File : ServerThread.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.io.*; 2 import java.net.*; 3 import java.util.*; 3 import java.lang.*; 4 5 public class ServerThread extends Thread{ 6 7 private String dataFromClient; 8 private int x, y, z; 9 private String valueX, valueY; 10 Socket serverSocket; 11 12 public ServerThread(Socket sck){ 13 serverSocket = sck; 14 } 15 16 public void run(){ 17 BufferedReader inFromClient; 18 DataOutputStream outToClient; 19 20 try{ 21 while(true){ 22 23 inFromClient = new BufferedReader(new 24 InputStreamReader(serverSocket.getInputStream())); 25 26 outToClient = new DataOutputStream(serverSocket. 27 getOutputStream()); 28 29 outToClient.writeBytes("InfoServer hanya untuk testing!! \n" + 30 " Pilih Perintah PENJUMLAHAN | PENGURANGAN| 31 PERKALIAN| SISABAGI| ALL| QUIT \n"); 32 boolean isQuit = false;

218


33 34 while(!isQuit){ 35 dataFromClient = inFromClient.readLine(); 36 37 if(dataFromClient.startsWith("PENJUMLAHAN")){ 38 outToClient.writeBytes("Masukkan Operand 39 1\n"); 40 dataFromClient = inFromClient.readLine(); 41 valueX = dataFromClient; 42 x = Integer.parseInt(valueX); 43 44 // System.out.println("Nilai X : " + valueX); 45 46 outToClient.writeBytes("Masukkan Operand 47 2\n"); 48 dataFromClient = inFromClient.readLine(); 49 valueY = dataFromClient; 50 y = Integer.parseInt(valueY); 51 52 // System.out.println("Nilai Y : " + valueY); 53 54 z = penjumlahan(x,y); 55 outToClient.writeBytes("PENJUMLAHAN\n"); 56 outToClient.writeBytes("Hasilnya : "+ z +" \n"); 57 58 }else if(dataFromClient.startsWith("PENGURANGAN")) 59 { 60 outToClient.writeBytes("Masukkan Operand 61 1\n"); 62 dataFromClient = inFromClient.readLine(); 63 valueX = dataFromClient; 64 x = Integer.parseInt(valueX); 65 66 // System.out.println("Nilai X : " + valueX); 67 68 outToClient.writeBytes("Masukkan Operand 69 2\n"); 70 dataFromClient = inFromClient.readLine(); 71 valueY = dataFromClient; 72 y = Integer.parseInt(valueY); 73 74 // System.out.println("Nilai Y : " + valueY); 75 76 z = pengurangan(x,y); 77 outToClient.writeBytes("PENGURANGAN\n"); 78 outToClient.writeBytes("Hasilnya : "+ z +" \n"); 79 80 }else if(dataFromClient.startsWith("PERKALIAN")){ 81 outToClient.writeBytes("Masukkan Operand 82 1\n"); 83 dataFromClient = inFromClient.readLine(); 84 valueX = dataFromClient;

219


85 x = Integer.parseInt(valueX); 86 87 // System.out.println("Nilai X : " + valueX); 88 89 outToClient.writeBytes("Masukkan Operand 90 2\n"); 91 dataFromClient = inFromClient.readLine(); 92 valueY = dataFromClient; 93 y = Integer.parseInt(valueY); 94 95 // System.out.println("Nilai Y : " + valueY); 96 97 z = perkalian(x,y); 98 outToClient.writeBytes("PERKALIAN\n"); 99 outToClient.writeBytes("Hasil Perkaliannya : 100 "+z+" \n"); 101 102 }else if(dataFromClient.startsWith("SISABAGI")){ 103 outToClient.writeBytes("Masukkan Operand 104 1\n"); 105 dataFromClient = inFromClient.readLine(); 106 valueX = dataFromClient; 107 x = Integer.parseInt(valueX); 108 109 // System.out.println("Nilai X : " + valueX); 110 111 outToClient.writeBytes("Masukkan Operand 112 2\n"); 113 dataFromClient = inFromClient.readLine(); 114 valueY = dataFromClient; 115 y = Integer.parseInt(valueY); 116 117 // System.out.println("Nilai Y : " + valueY); 118 119 z = sisaBagi(x,y); 120 outToClient.writeBytes("SISABAGI\n"); 121 outToClient.writeBytes("Hasilnya : "+ z +" \n"); 122 123 }else if(dataFromClient.startsWith("ALL")){ 124 outToClient.writeBytes("Masukkan Operand 125 1\n"); 126 dataFromClient = inFromClient.readLine(); 127 valueX = dataFromClient; 128 x = Integer.parseInt(valueX); 129 130 // System.out.println("Nilai X : " + valueX); 131 132 outToClient.writeBytes("Masukkan Operand 133 2\n"); 134 dataFromClient = inFromClient.readLine(); 135 valueY = dataFromClient; 136 y = Integer.parseInt(valueY);

220


137 138 // System.out.println("Nilai Y : " + valueY); 139 140 int z1 = penjumlahan(x,y); 141 int z2 = pengurangan(x,y); 142 int z3 = perkalian(x,y); 143 int z4 = sisaBagi(x,y); 144 145 outToClient.writeBytes("ALL\n"); 146 outToClient.writeBytes("Hasil Penjumlahan: 147 "+z1+"\n"); 148 outToClient.writeBytes("Hasil Pengurangan:"+ 149 z2+ "\n"); 150 outToClient.writeBytes("Hasil Perkalian : " + 151 z3+ "\n"); 152 outToClient.writeBytes("Hasil Sisa Bagi : " + z4+ 153 "\n"); 154 155 156 }else if(dataFromClient.startsWith("QUIT")){ 157 isQuit = true; 158 } 159 } 160 outToClient.close(); 161 inFromClient.close(); 162 serverSocket.close(); 163 System.out.println("Koneksi Client tertutup ... "); 164 } 165 166 }catch(IOException e){ 167 System.out.println("Error : " + e); 168 }catch(Exception e){ 169 System.out.println("Error : " + e); 170 } 171 } 172 173 174 public int penjumlahan(int a, int b){ 175 int z; 176 177 z = a+b; 178 return z; 179 } 180 181 public int perkalian(int a, int b){ 182 int z; 183 184 z = a*b; 185 return z; 186 } 187 188 public int pengurangan(int a, int b){

221


189 int z; 190 191 z = a-b; 192 return z; 193 } 194 195 public int sisaBagi(int a, int b){ 196 int z; 197 198 z = a % b; 199 return z; 200 } 201 202 }

Contoh 9.8 : /* * Nama File : MainServerThread.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.net.*; 2 import java.util.*; 3 4 public class MainServerThread{ 5 private final static int PORT = 2609; 6 7 public static void main(String[] args){ 8 try{ 9 ServerSocket infoServer = new ServerSocket(PORT); 10 11 System.out.println("Server telah siap..."); 12 while(true){ 13 Socket sock = infoServer.accept(); 14 15 System.out.println("Ada client terkoneksi !"); 16 new ServerThread(sock).start(); 17 } 18 19 }catch(Exception e){ 20 System.out.println("Ada kesalahan : " + e); 21 } 22 23 } 24 25 }

222


Pada contoh ini kita memberikan gambaran penggunakan multithreading java pada

aplikasi client server sederhana, dimana sebuah server dapat melayani beberapa client

secara bersamaan dengan meng-extends Thread pada bagian server. Layanan yang dapat

diberikan server kepada client adalah operasi aritmatik yaitu penjumlahan, pengurangan,

pembagian dan sisa bagi. Karena proses yang hendak dijalankan secara bersamaan adalah

proses aritmatika maka di dalam method run -nya kita memasukkan operasi aritmatika

tersebut, seperti yang dinyatakan pada baris 17 sampai 170. Saat terdapat suatu client

yang di accept oleh server seperti yang dinyatakan pada baris 13 maka server akan

menciptakan thread baru terhadap client yang baru di accept tersebut seperti yang

dinyatakan pada baris 16 contoh 9.8. Adapun hasil eksekusi dari listing program contoh

9.8 adalah seperti yang ditunjukkan dibawah ini :


Contoh 9.9 : /* * Nama File : Client.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.io.*; 2 import java.net.*; 3 import java.util.*; 4 5 public class Client{ 6 private final int PORT = 2609;

223


7 private final String targetHost = "localhost"; 8 private final String QUIT = "QUIT"; 9 10 public Client(){ 11 try{ 12 BufferedReader inFromUser = new BufferedReader(new 13 InputStreamReader(System.in)); 14 Socket clientSocket = new Socket(targetHost, PORT); 15 16 DataOutputStream outToServer = new 17 18 DataOutputStream(clientSocket.getOutputStream()); 19 BufferedReader inFromServer = new BufferedReader(new 20 InputStreamReader(clientSocket.getInputStream())); 21 22 System.out.println(inFromServer.readLine()); 23 System.out.println(inFromServer.readLine()); 24 25 System.out.println(""); 26 27 boolean isQuit = false; 28 29 while(!isQuit){ 30 System.out.println("Perintah Anda : "); 31 String cmd = inFromUser.readLine(); 32 33 cmd = cmd.toUpperCase(); 34 35 if(cmd.equals(QUIT)){ 36 isQuit = true; 37 } 38 outToServer.writeBytes(cmd + "\n"); 39 40 String result = inFromServer.readLine(); 41 System.out.println("Dari Server : " + result); 42 String valueX = inFromUser.readLine(); 43 outToServer.writeBytes(valueX + "\n"); 44 45 String result2 = inFromServer.readLine(); 46 System.out.println("Dari Server : " + result2); 47 String valueY = inFromUser.readLine(); 48 outToServer.writeBytes(valueY + "\n"); 49 50 51 String myCmd = inFromServer.readLine().toUpperCase(); 52 53 // System.out.println("Operatornya : " +myCmd); 54 if(myCmd.equals("PENJUMLAHAN")){ 55 String result3 = inFromServer.readLine(); 56 System.out.println("Dari Server : " + result3); 57 }else if(myCmd.equals("PENGURANGAN")){ 58 String result3 = inFromServer.readLine();

224


59 System.out.println("Dari Server : " + result3); 60 }else if(myCmd.equals("PERKALIAN")){ 61 String result3 = inFromServer.readLine(); 62 System.out.println("Dari Server : " + result3); 63 }else if(myCmd.equals("SISABAGI")){ 64 String result3 = inFromServer.readLine(); 65 System.out.println("Dari Server : " + result3); 66 }else if(myCmd.equals("ALL")){ 67 String result31 = inFromServer.readLine(); 68 System.out.println("Dari Server : " + result31); 69 String result32 = inFromServer.readLine(); 70 System.out.println("Dari Server : " + result32); 71 String result33 = inFromServer.readLine(); 72 System.out.println("Dari Server : " + result33); 73 String result34 = inFromServer.readLine(); 74 System.out.println("Dari Server : " + result34); 75 } 76 77 } 78 79 outToServer.close(); 80 inFromServer.close(); 81 clientSocket.close(); 82 83 84 }catch(IOException ioe){ 85 System.out.println(" Error : " + ioe); 86 }catch(Exception e){ 87 System.out.println(" Error : " + e); 88 } 89 } 90 91 public static void main(String[] args){ 92 new Client(); 93 } 94 }

Pada contoh 9.9 adalah linsting code di sisi client. Karena client hanya merequest

permintaan terhadapa server, dan tidak perlu meresponi atau me-request lebih dari pada

satu secara bersamaan, maka pada sisi client tidak perlu kita buatkan thread. Perlu

diperhatikan dalam pembuatan socket pada aplikasi client server dengan menggunkan

komunikasi connection-oriented dengan protokol TCP/IP disisi client harus mengetahui

alamat sever dan nomor port server seperti yang dinyatakan pada baris 14. Adapun hasil

eksekusi dari listing program contoh 9.9 adalah seperti yang ditunjukkan pada gambar

9.7. Saat adanya client client yang terhubung dengan server yang telah di accept oleh

225


server maka akan diinformasi ke pengguna seperti yang ditunjukkan pada gambar 9.8,

yaitu terdapat satu baris informasi jika dibandingkan dengan hasil eksekusi pada gambar

9.6. Informasi ini diberikan sesuai dengan lisnting code yang diberikan pada baris 15

contoh 9.8. Jika terdapat client baru yang me-request suatu permintaan terhadap server,

maka server akan meng-accept client, sehingga akan menampilkan baris informasi yang

sama, yaitu “Ada client terkoneksi”.

Gambar 9.7 Hasil eksekusi program contoh 9.9 sisi client

Gambar 9.8 Hasil eksekusi program contoh 9.8 sisi server

Dengan adanya thread yang kita gunakan pada server, yaitu dengan meng-extends Thread

seperti pada baris 5 contoh 9.7, maka client tersebut akan diresponsi dengan perlakuan

yang sama, seperti pada client yang pertama. Tetapi jika kita tidak meng-extends Thread,

maka saat terdapat dua client yang me-request terhadap suatu server, maka client tersebut

akan diantrikan dan menunggu responan dari server. Server akan dapat kembali me-

226


respon suatu client, saat client pertama yang sedang berkomunikasi telah meninggalkan

server. Ini berarti bahwa server hanya dapat melayani satu request-an dari client pada

suatu saat.

Dengan menjalankan client setelah memberikan operand yang akan dieksekusi atau diresponi oleh server kepada client akan diperoleh tampilan seperti yang ditunjukkan pada gambar 9.8.


227


Soal Latihan Bab 9. 1. Jelaskan apa yang dimaksud dengan thread pada Java.

2. Pembuatan Thread pada java dapat dilakukan dengan dua cara, jelaskan urutan langkah-

langkahnya.

3. Jelaskan cara menentukan prorioritas suatu thread. Berikan contohnya.

4. Buatlah aplikasi thread java sederhana untuk menjalankan 5 thread secara bersamaan.

Setiap thread ganjil akan menampilkan informasi “Thread nomorThread[3]” dan untuk

thread genap akan menampilkan informasi “Thread nomorThread[4]”. Masing-masing

thread menampilkan informasi sebanyak 10 kali. Untuk nomorThread akan memberikan

nomor thread yang dieksekusi saat itu, jadi jika saat itu sedang mengeksekusi thread 1

(satu), maka informasinya akan menampilkan “Thread 1[3]”.

5. Buatlah aplikasi client-server sederhana untuk memfasilitas client di dalam menentukan

nilai rata-rata dan nilai total suatu array dari client. Aplikasi server juga harus mampu

untuk melayani beberapa client secara bersamaan.

228


Bab 10 Graphical User Interface pada Java

Element dasar yang dibutuhkan di dalam menciptakan suatu GUI berada di dalam

package java.awt dan javax.swing. Package java.awt merupakan repository class yang

digunakan untuk menciptakan GUI didalam java1.1, awt singkatan dari Abstract

Windowing Toolkit, sedangkan javax.swing lebih merujuk pada java2. Secara umum

package javax.swing merupakan turunan dari package java.awt, sehingga saat

menggunakan class-class yang terdapat pada package javax.swing, kita telah

menggunakan semua kemampuan yang ada di dalam package java.awt. Misalkan dalam

menciptakan button kita menggunakan class Button pada package java.awt, sedangkan

pada package javax.swing, kita menggunakan class JButtun yang merupakan kelas

turunan dari class Button.

Kelas-kelas yang terdapat pada komponen swing juga lebih fleksibel

penggunaannya dari pada kelas-kelas yang terdapat pada komponen java.awt karena

komponen swing diimplementasikan pada java murni, dibandingkan komponen awt yang

tergantung pada native code yang lebih besar. Karena komponen swing murni java, maka

penggunaan komponen swing tidak akan terbatas oleh karakteristik dari platform yang

berjalan saat itu. Komponen swing juga menyediakan fitur yang disebut pluggable look-

and-feel yang memungkinkan perubahan tampilan dari suatu komponen. Kita dapat

secara programming memilih look-and-feel suatu komponen dengan pengimplementasian

standar atau dengan menciptakan look-and-feel sendiri. Pengimplementasian ini

difasilitasi oleh pendesaianan kelas-kelas dengan cara tertentu yang disebut dengan

arsitektur MVC .

Arsitektur MVC (Model-View-Controller) merupakan suatu cara ideal dalam

pemodelan suatu komponen. Adapun MVC itu adalah :

1. Model yang menyimpan data yang mendefinisikan komponen

2. View yang menciptakan representasi visual komponen dari data dalam model

3. Controller yang menghubungkan interaksi user dengan komponen dan modifier

dan view yang meresponini aksi user yang diberikan pengguna.

229


Dalam istilah berorientasi objek, setiap komponen memiliki ketiga bagian lojikal

tersebut, yaitu memodelkan, melihat dan mengontrol yang akan direpresentasikan oleh

suatu tipe kelas yang berbeda. Adapun model arsitektur MVC adalah seperti yang

ditunjukkan pada gambar 10.1.

Gambar 10.1 Model Arsitektur MVC

Dalam prakteknya ketiga bagian lojikal tersebut sangat sulit karena

diimplementasikan karena sangat tergantung antara melihat (view) dan pengontrolan

(controller). Operasi controller sangat tergantung pada implementasi view pengguna yang

berinteraksi dengan tampilan fisik suatu komponen. Karena alasan tersebut maka view

dan controller biasanya direpresentasikan oleh suatu objek komposit view dan terintegrasi

dengan controller. Dalam hal ini, konsep MVC dibangkitkan pada kelas Observable dan

interface Observer, yang disebut dengan Model arsitektur Separable. Adapun model

arsitektur Separable adalah seperti yang ditunjukkan pada gambar 10.2.

Gambar 10.2 Model Arsitektur Separable

230


10.1 Penciptaan Window

Window dasar pada java di representasikan oleh suatu objek class window yang

ada package java.awt. Objek class Window sangat sukar digunakan secara langsung

karena borders dan penerapan title bar pada objek window sangat sukar diaplikasikan.

Class JFrame, yang didefinisikan pada package javax.swing, merupakan cara yang paling

mudah digunakan dalam penciptaan suatu window, karena border dan title bar telah

difasilitasi di dalam class JFrame ini. Komponen penciptaan suatu window ditunjukkan

seperti pada gambar 10.3.

Gambar 10.3 hirarki komponen suatu window.

Class Component adalah class dasar dari semua class component, yang mendefinisikan

properti dasar dan method yang dapat digunakan oleh semua component. Class

Container memiliki kemampuan tambahan di dalam menambahkan objek component ke

dalam component yang lain. Karena JFrame memiliki Container sebagai suatu super

class, maka suatu objek JFrame dapat memuat components yang lain. Kemampuan inilah

yang sangat diperlukan di dalam membangun suatu aplikasi window yang

merepresentasikan GUI, misalkan suatu menubar memiliki menus, dimana satu menu

dapat mengandung lebih dari satu item menu; satu toolbar dapat memiliki buttons, dan

lain sebagainya. Inilah alasan class Container menjadi dasar di dalam semua class di

dalam mendefinisikan components swing.

231


Class Window menambahkan methods ke dalam class Container yang secara khusus

kepada window, seperti kemampuan dalam menangani event yang dimunculkan interaksi

pengguna pada window. Class Frame merupakan class dasar yang berada di java.awt

yang memiliki kemampuan sifat-sifat window, yaitu satu title bar dan satu border. Class

JFrame didalamnya ditambahkan fungsionalitas dari Frame untuk mendukung berbagai

kemampuan yang menekankan pada proses penggambaran dan menampilkan components

yang lain. Saudara dapat mengurangi kompleksitas penggunaan methods, yang terdiri

200+ methods dari ke lima superclass, yang ada di dalam hirarki class di atas dengan

menggunakan JFrame.

Saudara dapat menampilkan suatu aplikasi window sederhana dengan penciptaan objek

bertipe JFrame, pemanggilan suatu method untuk menset ukuran window, kemudian

pemanggilan suatu method untuk menampilkan window tersebut. Seperti yang

ditunjukkan pada source code dibawah ini :

Contoh 10.1:

/* * Nama File : TryWindow.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import javax.swing.*; 2 public class TryWindow{ 3 static JFrame aWindow = new JFrame("This is the Window Title");

4 public static void main(String[] args){ 5 aWindow.setBounds(50, 100, 400, 150); //set posisi dan ukuran 6 aWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 7 aWindow.setVisible(true);

8 } 9 }

Dari listing code contoh 10.1 kita perhatikan bahwa pada baris 3, kita telah membuat

suatu objek aWindow dari class JFrame dengan nama window “This is the Window

Title”. Ukuran window yang akan terbentuk adalah panjang 400 pixel dan lebar 150 pixel

dengan koordinat awal pada titik 50 pixel dari sisi kiri ke kanan monitor dan 100 pixel

dari sisi atas ke bawah monitor, seperti yang dinyatakan pada baris 5. Pada baris 6 kita

232


meninta controller untuk menutup window saat meng-click . Objek aWindow yang

telah terbentuk akan ditampilkan oleh component view dengan memanggil method

setVisible yang bernilai “true”, seperti yang dinyatakan pada baris 7. Adapun hasil

eksekusi dari listing program contoh 10.1 adalah seperti yang ditunjukkan pada gambar

10.3.


Terdapat empat nilai argumen yang mungkin yang dapat digunakan di dalam menset nilai

setDefaultCloseOperation( ), yaitu :

1. JFrame.EXIT_ON_CLOSE, menutup window, menghancurkan resource dan

component yang lain yang dimuat di dalam window, dan akhirnya akan

mengakhiri aplikasi.

2. JFrame.DISPOSE_ON_CLOSE, menyebabkan Frame dan components yang ada

di dalam window dihancurkan tetapi aplikasi masih tetap berjalan.

3. JFrame.DO_NOTHING_ON_CLOSE, menyebabkan tidak berfungsinya fungsi

penutupan operasi.

4. JFrame.HIDE_ON_CLOSE, hanya menyembunyikan window dengan memanggil

method setVisible( ) dengan argument false. Jika ingin menampilkan window lagi

Saudara hanya memanggil method setVisible dengan argument true.

233


10.2 Components dan Containers

Suatu komponen adalah suatu objek class dari sub class Component. Window JFrame

merupakan suatu komponen. Semua class yang diturunkan dari class Container dapat

mengandung objek-objek dari class turunan Component. Karena class Container adalah

sub-class dari class Component. Setiap objek container adalah suatu Component juga,

sehingga suatu container dapat mengandung container yang lain. Kecuali di dalam class

window dan sub class-nya, objek window tidak dapat mengandung container yang lain.

Class JComponent adalah class untuk semua component swing yang digunakan dalam

suatu window sebagai bagian dari GUI, sehingga karena class ini diturunkan dari

Container, maka semua component swing juga container.

Class JApplet merupakan class dasar untuk semua swing applet, yang diturunkan dari

Component melalui class Container. Suatu Applet akan mewarisi method yang ada di

class Component melalui class Container. Sehingga class JApplet, JFrame, JDialog, dan

JComponent dan sub-class-nya semuanya berada di dalam package javax.swing. Perlu

diperhatikan bahwa class Applet berada pada package java.applet, sedangkan class

yang lainnya terdapat pada package java.awt. Adapun hirarki dari komponen-komponen

tersebut adalah seperti yang ditunjukkan pada gambar 10.4.

Gambar 10.4 Hirarki dari Component

234


10.3 Komponen Window dan Komponen Frame

Perbedaan dasar antara suatu objek JFrame dengan objek Window adalah bahwa suatu

objek JFrame merepresentasikan window utama bagi suatu aplikasi, sedangkan suatu

objek Window tidak. Di dalam menciptakan suatu objek window selalu membutuhkan

suatu objek JFrame.

Karena class JDialog diturunkan secara langsung dari class Window, maka Saudara

hanya dapat menciptakan suatu objek JDialog di dalam suatu objek JFrame. Konstruktor

class JDialog secara umum membutuhkan suatu objek JFrame dalam pengiriman suatu

argumen. Objek JFrame dirujuk sebagai parent dari objek JDialog. Objek JFrame

memiliki suatu border yang ukurannya dapat kita tentukan dan juga mempunyai

kemampuan untuk memegang suatu menu bar. Karena objek JFrame berapa pada hirarki

yang paling atas suatu aplikasi, ukuran dan pelokasiannya ditentukan berdasarkan

screennya.

Secara umum dapat disimpulkan bahwa,

1. JFrame, digunakan sebagai dasar window aplikasi pada Java. Suatu objek dari

class ini memiliki suatu title bar dan kemampuan menambahkan suatu menu,

kemudian dapat juga menambahkan components kepadanya. Saudara dapat

menggunakan subclass ini untuk menciptakan suatu window tertentu kepada

aplikasi saudara. Sehingga dimungkinkan untuk menambahkan component GUI

atau menggambar di dalam window, jika dibutuhkan.

2. JDialog, digunakan untuk mendefinisikan suatu window dialog yang digunakan

untuk memasukkan data ke dalam program dalam berbagai cara.

3. JApplet, class dasar untuk Applet pada Java 2, yaitu suatu program tertanam yang

didesain untuk berjalan di dalam suatu web page.

4. JComponent, sub class dari JComponent mendefinisikan suatu standar component

seperti menus, buttons, checkboxes dan sebagainya. Gunakan class ini untuk

menciptakan GUI aplikasi atau applet.

JApplet, JFrame dan JDialog merupakan class container, karena kelas-kelas tersebut

masing-masing memiliki Container sebagai base class, yang dapat mengandung berbagai

235


komponen. Kelas-kelas tersebut juga merupakan suatu componen karena kelas-kelas

tersebut juga merupakan turunan langsung dari class Component seperti yang


10.4 Window Panes

Saat saudara ingin menambahkan komponen GUI atau menggambar suatu window yang

ditampilkan dari JFrame, suadara menambahkan components ke suatu window pane

yang diatur oleh objek JFrame.

Pada gambar 10.5 kita perhatikan bahwa daerah dibawah title bar suatu objek JFrame

berhubungan dengan JRootPane. Objek JRootPane mengandung pane yang lain yang

dalam hal ini adalah layeredPane tipe JLayeredPane. Pane ini dialokasikan pada

JRootPane. Jika pada layeredPane window terdapat menuBar maka layeredPane akan

mengatur dan mengontrol menuBar. Daerah dibawah menuBar pada layeredPane

berhubungan dengan objek contentPane tipe JInternalPane. Pada objek con

layeredPane tentPane saudara dapat menambahkan komponen GUI. Saudara dapat juga

menampilkan text atau menggambar pada daerah yang dirujuk olej contentPane.

JFrame window

Optional menuBar

layeredPane object of type JLayeredPane

contentPane object of type JInternalPane

The area of the window below the title bar corresponds to a JRootPane object

Gambar 10.5 JFrame window

236


Objek layeredPane pada aplikasi yang lebih tinggi memiliki sifat khusus dalam

mengatur kelompok componen pada layer yang berbeda, yang dapat melapisi antara satu

pane dengan pane yang lain. Dengan fitur ini maka saudara dapat mengontrol bagaimana

componen ditampilkan dalam suatu urutan tertentu. Sehingga akan ditampilkan pada

screen sesuai dengan urutan yang telah saudara buat, apakah dari muka ke belakang

kemudian kembali ke belakang atau sebaliknya.

Untuk menampilkan pane yang selalu muncul pada posisi atas dari pane yang lain

dapat saudara menggunakan objek glassPane, seperti penggunaan pop-up menus.

glassPane dapat juga digunakan untuk menampilkan grafik yang selalu mengalami

perubahan (update) pada periode tertentu, seperti penciptaan suatu animasi. Untuk

menampilkan latar (background) yang bersifat statik saudara menggunakan secara bebas

dengan contentPane.

Pada class JFrame mendefinisikan beberapa methods berikut :

1. getRootPane( ), mengembalikan root pane sebagai type JRootPane.

2. getLayeredPane( ), mengembalikan layer pane dengan type JlayeredPane.

3. getContentPane( ), mengembalikan conten pane sebagai type Conteiner. Method

ini yang akan paling sering dipergunakan karena untuk menambahkan component

gunakan content pane.

4. getGlassPane( ), mengembalikan glass pane dengan type Component

10.5 Dasar-dasar Components

Saat suatu component dimasukkan di dalam component yang lain, outer object dirujuk

sebagai parent. Saudara dapat mencari parent dari suatu component dengan menggunakan

method getParent( ). Method ini diturunkan dari class Component dan mengembalikan

parent dengan type Container, karena hanya sub class Container yang memegang

component yang lain. Berikut ini beberapa method yang sering digunakan pada class

component :

1. setLocation( ), menset lokasi dari componen yang berhubungan dengan

parentnya.

2. setName( ), menset nama dari suatu componen dengan nilai string tertentu.

3. setBounds( ), menentukan posisi dan ukuran suatu componen

237


4. setSize( ), menentukan ukuran persegi panjang dari suatu componen

5. getLocation( ), mengembalikan lokasi dari suatu componen yang berhubungan

dengan paren suatu componen tersebut.

6. getName( ), mengembalikan nama dari sutu componen

7. getBounds( ), mengembalikan nilai posisi dan ukuran suatu componen yang telah

didefinisikan kepada componen.

8. getSize( ), mengembalikan panjang dan lebar component yang telah didefinisikan

kepada componen

9. getToolkit( ), mengembalikan objek Toolkit, membantu menset ukuran dan posisi

dasi suatu window pada suatu screen.

10. setBackground( ), menentukan warna latar (background) suatu componen.

11. getBackground( ), mengembalikan warna latar suatu componen.

12. getForeground( ), mengembalikan warna bingkai suatu componen

13. setCursor( ), menentukan cursor dari suatu objek

14. setFont( ), menentukan font dari suatu objek

15. getFont( ), mengembalikan ukuran font dari suatu objek.

10.6 Component Swing

Semua component swing didefinisikan di dalam package javax.swing, dan nama

classnya dimulai dengan huruf J. Componen swing semuanya memiliki class

JComponent sebagai suatu class dasar dimana class tersebut merupakan perluasan dari

class Componen, dengan menambahkan kemampuan berikut ini :

1. Mendukung pluggable look-and-feel bagi componen, yang memperbolehkan

untuk mengubah look-and-feel secara programming, dan pengimplementasian

bagi setiap componen yang akan ditampilkan.

2. Mendukung tooltips, suatu pesan yang memberikan gambaran tujuan dari suatu

component saat cursor mouse di hubungankan ke dalam component tersebut.

Tooltips di definisikan oleh class JTooltip.

3. Mendukung scrolling secara otomatis pada suatu list, suatu table atau tree saat

suatu componen di perkecil atau diperbesar dengan mouse.

238


4. Mendukung debugging khusus pada grafik, menyediakan componen dalam

pergerakan lambat sehingga dapat dilihat perubahan.

5. Componen class dapat secara mudah diperluas (extend) untuk mencipatakan suatu

componen tertentu.

10.6.1 Buttons

Class swing button mendefinisikan berbegai jenis button yang beroperasi pada

operasi click mouse. Class Button memiliki base class AbstractButton, seperti yang


Gambar 10.6 Component Button

Class JButton mendefinisikan suatu puhbutton yang teratur, yang dapat digunakan

sebagai button dialog atau pada suatu toolbar. Class JToggleButton mendefinisikan dua

keadaan state button, yaitu ditekan (pressed) atau tidak. Terdapat dua jenis

JToggleButton, yaitu JCheckBox dan JRadioButton. Objek JRadioButton secara umum

beroperasi pada pada suatu group sehingga hanya button tertentu yang dapat ditekan pada

suatu waktu tertentu. Untuk mengelompokkan JRadioButton dilakukan dengan

penambahan JRadioButton pada objek ButtonGroup. Objek JCheckBox merupakan

button yang perubahan statenya dinyatakan dengan cara meng-click checkbox dari state

check atau tidak.

10.6.2 Menus

239


Component swing memuat (support) pop-up menu atau menu teks seperti menu

bar. Elemen-elemen dari suatu menu didefinisikan seperti yang ditunjukkan pada gambar

10.7.

Class JMenuBar mendefinisikan suatu menubar yang biasanya ditemukan pada

aplikasi window yang paling atas. Objek JMenu merepresentasikan menu item pada level

tertinggi pada suatu menubar sehingga akan mem-pop-up suatu list menu item saat objek

JMenu di-click. Item-item yang ditampilkan pada menu ini didefinisikan oleh class

JMenuItem. Class JPopupMenu mendefinisikan suatu konteks menu yang biasanya

diimplementasikan saat menekan mouse dengan click kanan. Class JCheckBoxMenuItem

adalah suatu menu item yang untuk menampilkannya dengan men-checkbox item yang

akan dipilih. Class JRadioButtonMenuItem mendefinisikan suatu menu item sebagai

suatu bagian dari suatu group menu item yang hanya dapat dipilih pada waktu tertentu.

Gambar 10.7 Component Menus

10.6.3 Text

Component swing text memiliki kemapuan yang sangat luas. Component text

yang paling dasar adalah objek JLabel. Elemen-elemen dari component text adalah


240


Gambar 10.8 Component Text

Component JLabel merupakan suatu component pasif yang tidak mempunyai

rekasi terhadap suatu kejadian, sehingga tidak dapat diubah. Component JTextField

merupakan componen yang dapat menampilkan satu baris teks, tetapi dalam hal ini dapat

diubah. JTextArea mendefinisikan suatu component yang dapat menampilkan beberapa

baris teks dan dapat diubah. Pada JTextArea akan menambahkan scrollbar secara

otomatis saat akan menampilkan beberapa baris dan kolom. JEditPane mendukung

pengeditan plain text, text HTML dan RTF (Rich Text Format). JTextPane merupakan

perluasan (extend) dari JEditPane dan memperbolehkan didalam meletakkan image atau

komponen yang lain pada text yang dimiliki oleh component.

10.7 Penggunaan Container

Semua komponen swing merupakan container, suatu Container adalah suatu

component dengan base class Container. Class container merupakan base class bagi

class window dan menyediakan kemampuan untuk mengandung komponen yang lain.

Karena Window, JFrame, atau JDialog class turunan dari class Container, maka objek-

objek tersebut akan mewarisi kemampuan container untuk mengandung component yang

lain.

Component pada suatu container ditampilkan pada suatu daerah area screen diatur

oleh container. Sebagai contoh, suatu window dapat mengandung objek JList yang

memberikan kemampuan untuk pemilihan item, objek JCheckbox yang memberikan

kemampuan untuk pemilihan yang lain, dan objek JButton yang memberikan kemampuan

bagi pengguna untuk menekan button dan lain sebagainya, semua component ini akan

241


dapat digunakan dan dilihat pengguna tentu saat container telah ditampilkan. Container

dapat juga mengontrol bagaimana component diletakkan.

10.8 Container Layout Managers

Layout manager mendefinisikan cara component disusun di dalam suatu container.

Semua container akan memiliki suatu default layout manager tetapi jika hendak

menyusun tampilan sesuai dengan keinginan dapat dilakukan dengan mengatur layout

manger. Layout manager disimpan di dalam package java.awt dan javax.swing. Layout

manager bagi suatu container digunakan untuk menentukan posisi dan ukuran dari semua

component di dalam container.

1. FlowLayout, default untuk JPanel

2. BorderLayout, default untuk contentPane dalam suatu objek JFrame, JDialog atau

JApplet

3. CardLayout, hanya menampilkan component yang paling atas seperti kartu yang

tersusun.

4. GridLayout, mengatur ukuran grid dari baris dan kolom dalam ukuran tertentu.

5. GridBagLayout, mengatur ukuran dari baris dan kolom suatu component tetapi

lebih panjang dan lebih fleksibel.

6. BoxLayout, menyusun component dalam baris dan kolom. Default untuk class

Container Box

10.9 Proses Penanganan Event

Untuk mengatur interaksi pengguna pada suatu GUI, kita harus mengerti

penanganan-penganan event yang ada di Java. Button merupakan source dari suatu event.

Event di generate sebagai hasil dari perlakuan mouse terhadap objek JButton. Suatu event

selalu memiliki suatu objek source. Saat button di-click, maka objek tersebut akan men-

generate suatu objek sehingga merepresentasikan dan mengidentifikasi event-nya, dalam

hal ini suatu event dinyatakan suatu objek dengan dari type ActionEvent, seperti yang


242


Interface ActionListener perlu untuk di implementasikan dalam menerima event

yang terjadi, karena code untuk menerima objek event ditangani oleh ActionListener.

Saat event terjadi maka method actionPerformed( ) dipanggil oleh objek tersebut. Untuk

menghubungkan objek event dengan pemanggilan method actionPerformed dilakukan

dengan cara menanggil method addActionLister( ) pada objek yang hendak ditangani

responnya.

OK

Butto

n C

lick

ActionEvent

Object

public class MyClass implements ActionListener

{

//class members

//constructor..

button.addActionListener(this);

void actionPerformed(ActionEvent e){

// handle the event

}

}

Passed to

cre

ate

s

Listener menghubungkan ke event

source dgn memanggil method

addActionListener()

Gambar 10.9 Proses penanganan Event

Event Classes

Terdapat berbagai jenis event yang perlu ditangani di dalam meresponi program yang

saudara buat, yaitu dari menus, buttons, mouse, keyboard, dan lain sebagainya. Dalam

penanganan event ini, dapat dipecah ke dalam sub class. Pada level tertinggi terdapat dua

categori event, yaitu :

1. Low-level Event, event yang terjadi akibat reaksi keyboard atau mouse, atau yang

berhubungan dengan operasi pada windows seperti closing window.

2. Semantic Event, event yang berhubungan dengan komponen khusus seperti

penekanan button, peng-click-an button, penyimpanan menu Save, pemilihan

item.

243


Low-level Event Class

Terdapat 4 jenis low-level event,

1. FocusEvent,

2. MouseEvent,

3. KeyEvent,

4. WindowEvent,

Low-Level Event Listener

Terdapat lima interface low-level event listener, yaitu

1. WindowListener,

2. MouseListener,

3. MouseMotionListener,

4. KeyListener,

5. FocusListener,

Semantic events

Semantic events berhubungan dengan operasi dari komponen GUI bagi program. Jika

saudara memelih item atau meng-click button, semantic event akan degenerate. Terdapat

3 kelas semantic event, yaitu :

1. ActionEvent,

2. ItemEvent,

3. AdjustmentEvent,

Semantic Event Listener

Terdapat tiga interface semantic event listener, yaitu

1. ActionListener,

2. ItemListener,

3. AdjustmentListener,

244


10.10 Penambahan Menu pada suatu Window

Objek JMenuBar merepresentasikan menu bar yang ditempatkan pada bagian atas

window. Saudara dapat menambahkan objek JMenu atau JMenuBar akan ditampilkan

pada menu bar. Objek JMenu adalah suatu menu item dengan suatu label yang dapat

ditampilkan menu pull-down saat di-click. JMenuItem dapat mempunyai suatu icon atau

penambahan label string. Penciptaan suatu menu dapat dilakukan dengan cara,

JMenu filemenu = new JMenu(“File”);

Sedangkan untuk menciptakan suatu JmenuItem dapat dilakukan dengan cara,

JMenuItem openMenu = new JMenuItem(“Open”);

Untuk menciptakan suatu objek JcheckboxMenuItem dengan item yang tidak di check

dapat dilakukan dengan cara berikut,

JCheckboxMenuItem circleItem = new JCheckbocMenuItem(“Circle”);

Sedangkan untuk menciptakan menu objek yang sudah di check dapat dilakukan dengan

cara berikut,

JCheckboxMenuItem circleItem = new JCheckbocMenuItem(“Circle”, true);

10.11 Penambahan Shortcut bagi suatu Menu Item

Suatu shortcut adalah suatu kombinasi kunci tunggal yang digunakan untuk memilih

suatu menu pada menu bar secara langsung dari keyboard. Untuk menambahkan suatu

shortcut pada menu menu item File dapat dilakukan dengan cara menambahkan statement

berikut;

filemenu.setMnemonic(‘F’);

Method setMnemonic( ) diturunkan dari class AbstractButton.

Suatu accelerator adalah suatu kombinasi kunci yang dapat dimasukkan untuk memilih

suatu item dari suatu menu. Method setAccelerator( ) didefinisikan sebagai suatu

akselerator. Yang dapat diimplementasikan sebagai berikut;

lineItem.setAccelerator(KeyStroke.getKeyStroke(‘L’, Event.CTRL_MASK));

Gunakan Event.SHIFT_MASK, untuk shift, dan gunakan Event.ALT_ MASK untuk alt,

sedangkan untuk kombinasinya dapat dilakukan dengan cara Event.ALT_MASK +

Event.CTRL_MASK

245


Contoh 10.2 :

/* * Nama File : TryWindow3.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import javax.swing.*; 2 import java.awt.*; 3 4 public class TryWindow3{ 5 static JFrame aWindow = new JFrame("This is the Window Title"); 6 public static void main(String[] args){ 7 Toolkit theKit = aWindow.getToolkit(); // mengambil window tollkit 8 Dimension wndSize = theKit.getScreenSize(); 9 10 aWindow.setBounds(wndSize.width/4,wndSize.height/4, 11 wndSize.width/2, wndSize.height/2); //set posisi dan ukuran 12 aWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 13 14 aWindow.setCursor(Cursor.getPredefinedCursor( 15 Cursor.CROSSHAIR_CURSOR)); 16 aWindow.getContentPane().setBackground(Color.pink);; 17 aWindow.setVisible(true); 18 } 19 }


246


Pencipataan suatu aplikasi yang berbasis window dengan warna background tertentu

cukup sederhana, hanya membutuhkan beberapa baris listing code, seperti yang dapat

kita lihat pada contoh 10.2. Window yang kita ciptakan diperoleh dari objek turuna

JFrame seperti yang dinyatakan pada baris 5. Baris 7 kita mengambil window tolkit dari

monitor komputer kita. Pada baris 8, kita mengambil ukuran layar monitor computer kita,

dengan menggunakan method getScreenSize( ). Kemudian pada baris 10 dan 11, kita

mengatur tampilan window agar tepat berada di tengah-tengah monitor kita. Pada baris

12 objek aWindow menggunakan operasi EXIT_ON_CLOSE, akibatkan saat window

tersebut kita close, maka sumber daya yang dipegang oleh objek aWindow akan

dihancurkan. Baris 14 dan 15 kita memintak untuk men-set cursor yang digunakan adalah

CROSSHAIR_CURSOR. Sedangkan untuk men-set background dari layar window kita

dengan warna pink, cukup dinyatakan dengan memintak objek aWindow untuk men-set

getContentPane( ) dengan men-set setBackground( ) dengan warna yang kita inginkan,

seperti yang dinyatakan pada listing code pada baris 16. Adapun hasil eksekusi dari

listing program contoh 10.10 adalah seperti yang ditunjukkan pada gambar 10.10.

Contoh 10.3 :

/* * Nama File : TryWindow4.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import javax.swing.*; 2 import java.awt.*; 3 import javax.swing.ImageIcon; 4 import java.io.*; 5 import java.net.*; 6 7 8 public class TryWindow4 extends JFrame{ 9 // static JFrame aWindow = new JFrame("This is the Window Title"); 10 public static void main(String[] args){ 11 TryWindow4 aWindow = new TryWindow4(); 12 13 14 aWindow.setBounds(50, 100, 400, 400); // set posisi dan ukuran 15 aWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

247


16 aWindow.setVisible(true); 17 18 try { 19 URL iconUrl = new URL("file", "localhost", "myIcon.jpg"); 20 ImageIcon icon = new ImageIcon(iconUrl); 21 aWindow.setIconImage(icon.getImage()); 22 } 23 catch (Exception e) { /* Not important */ } 24 25 } 26 }

Untuk memberikan icon atau gambar pada suatu window, sangatlah sederhana, yaitu

dengan men-set setIconImage pada objek aWindow, seperti yang dinyatakan pada listing

code contoh 10.3 baris 21. Agar image tersebut dapat diakses, maka terlebih dahulu kita

harus mendeklarasikan dimana image tersebut berada, seperti yang dinyatakan pada baris

19. Kemudian kita membentuk objek image dengan menggunakan constructor

ImageIcon(), dengan argument yang diberikan adalah alamat dimana objek image tersebut

berada seperti yang dinyatakan pada baris 20. Adapun hasil eksekusi dari listing program

contoh 10.3 adalah seperti yang ditunjukkan pada gambar 10.3.


Contoh 10.4 :

248


/* * Nama File : TryBox.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import javax.swing.*; 2 import java.awt.*; 3 import javax.swing.ImageIcon; 4 import java.io.*; 5 import java.net.*; 6 import javax.swing.border.*; 7 8 public class TryBox extends JFrame{ 9 public static void main(String[] args){ 10 TryGridLayout aWindow = new TryGridLayout(); 11 12 Toolkit theKit = aWindow.getToolkit(); 13 Dimension wndSize = theKit.getScreenSize(); 14 aWindow.setBounds(wndSize.width/4,wndSize.height/4, 15 wndSize.width/2, wndSize.height/2); // set posisi dan ukuran 16 aWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 17 18 try { 19 URL iconUrl = new URL("file", "localhost", "myIcon.jpg"); 20 ImageIcon icon = new ImageIcon(iconUrl); 21 aWindow.setIconImage(icon.getImage()); 22 } 23 catch (Exception e) { /* Not important */ } 24 25 // create left columns of radio buttons 26 Box left = Box.createVerticalBox(); 27 ButtonGroup radioGroup = new ButtonGroup(); 28 JRadioButton rbutton; 29 30 radioGroup.add(rbutton = new JRadioButton("Red")); 31 left.add(rbutton); 32 radioGroup.add(rbutton = new JRadioButton("Green")); 33 left.add(rbutton); 34 radioGroup.add(rbutton = new JRadioButton("Blue")); 35 left.add(rbutton); 36 radioGroup.add(rbutton = new JRadioButton("Yellow")); 37 left.add(rbutton); 38 39 // create right columns of checkboxes 40 Box right = Box.createVerticalBox(); 41 right.add(new JCheckBox("Dashed")); 42 right.add(new JCheckBox("Thick")); 43 right.add(new JCheckBox("Rounded")); 44 45 // create top row to hold left and right 46 Box top = Box.createHorizontalBox();

249


47 top.add(left); 48 top.add(right); 49 50 // create bottom row of buttons 51 JPanel bottonPanel = new JPanel(); 52 Border edge = BorderFactory.createRaisedBevelBorder(); 53 JButton button; 54 55 Dimension size = new Dimension(80, 20); 56 bottonPanel.add(button = new JButton("Default")); 57 button.setBorder(edge); 58 // menjamin bahwa ukuran button yang diperbolehkan sesuai dengan ukuran size 59 button.setPreferredSize(size); 60 bottonPanel.add(button = new JButton("OK")); 61 button.setBorder(edge); 62 button.setPreferredSize(size); 63 bottonPanel.add(button = new JButton("Cancel")); 64 button.setBorder(edge); 65 button.setPreferredSize(size); 66 67 // add top panel to content pane 68 Container content = aWindow.getContentPane(); 69 content.setLayout(new BorderLayout()); 70 content.add(top, BorderLayout.CENTER); 71 content.add(bottonPanel, BorderLayout.SOUTH); 72 73 aWindow.setVisible(true); 74 } 75 }

250



Pada contoh 10.4 kita memberikan gambaran pencipataan komponen radio button,

checkbox, dan button. Baris 26 dan 40 kita mendekalrasikan dua buah komponen box,

untuk meletakkan komponen checkbox yang akan kita masukkan ke dalam komponen

tersebut. Untuk menciptakan suatu komponen radio button cukup sederhana seperti yang

dinyatakan pada baris 30, kemudian kita memasukkan komponen tersebut ke Box dengan

menggunakan method add( ). Pada baris 70 dan 71 kita memasukkan panel dan box yang

kita telah buat ke dalam container kita. Agar dapat dilihat oleh pengguna kita

menggunakan method setVisible() yang bernilai true, seperti yang dinyatakan pada baris

73. Adapun hasil eksekusi dari listing program contoh 10.4 adalah seperti yang


Contoh 10.5 :

/* * Nama File : SketchFrame.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

251


1 import javax.swing.*; 2 3 public class SketchFrame extends JFrame{ 4 5 private JMenuBar menuBar = new JMenuBar(); 6 // Constructor 7 public SketchFrame(String title){ 8 setTitle(title); // set window title 9 setDefaultCloseOperation(EXIT_ON_CLOSE); 10 setJMenuBar(menuBar); // add the menu to the window 11 12 JMenu fileMenu = new JMenu("File"); // create the File menu 13 // create the Element menu 14 JMenu elementMenu = new JMenu("Elements"); 15 menuBar.add(fileMenu); 16 menuBar.add(elementMenu); 17 } 18 }

Contoh 10.6 : /* * Nama File : Skecther.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.awt.*; 2 3 public class Sketcher{ 4 5 static SketchFrame window; 6 7 public static void main(String[] args){ 8 window = new SketchFrame("Sketcher"); // create application window 9 10 Toolkit theKit = window.getToolkit();// get the window toolkit 11 Dimension wndSize = theKit.getScreenSize(); // get screen size 12 13 // set the position to screen 14 window.setBounds(wndSize.width/4,wndSize.height/4, 15 wndSize.width/2, wndSize.height/2); 16 17 window.setVisible(true); 18 } 19 }

252



Untuk membuat suatu menu bar pada suatu aplokasi berbasis window, cukup dengan

menggunakan JMenuBar seperti yang dinyatakan pada baris 5 conoth 10.5. untuk

menciptakan suatu menu yang akan kita masukkan ke dalam suatu menu bar, cukup

dilakukan dengan menggunakan JMenu seperti yang dinyatakan pada baris 12 dan 14.

Untuk memasukkan suatu objek menu ke menubar dapat dilakukan dengan menggunakan

suatu method add( ), seperti yang dinyatakan pada baris 15 dan 16. Ketika conoth 10.6

kita jalankan, maka pada baris 8 akan memintak class pada contoh 10.5 untuk

membentuk suatu window. Adapun hasil eksekusi dari listing program contoh 10.6


Contoh 10.7:

/* * Nama File : SketchFrame.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import javax.swing.*; 2

253


3 public class SketchFrame extends JFrame{ 4 5 private JMenuBar menuBar = new JMenuBar(); 6 7 // File menu items 8 private JMenuItem newItem, openItem, closeItem,saveItem, saveAsItem, 9 printItem; 10 11 // ELement menu items 12 private JRadioButtonMenuItem lineItem, rectangleItem, circleItem, curveItem; 13 private JCheckBoxMenuItem redItem, yellowItem, greenItem, blueItem; 14 15 16 // Constructor 17 public SketchFrame(String title){ 18 setTitle(title); // set window title 19 setDefaultCloseOperation(EXIT_ON_CLOSE); 20 21 setJMenuBar(menuBar); // add the menu to the window 22 23 JMenu fileMenu = new JMenu("File"); // create the File menu 24 // create the Element menu 25 JMenu elementMenu = new JMenu("Elements"); 26 27 // Constructor the file pull down menu 28 newItem = fileMenu.add("New"); 29 openItem = fileMenu.add("Open"); 30 closeItem = fileMenu.add("Close"); 31 saveItem = fileMenu.add("Save"); 32 saveAsItem = fileMenu.add("Save As ..."); 33 fileMenu.addSeparator(); 34 printItem = fileMenu.add("Print"); 35 36 37 // Constructor the Element pull down menu 38 elementMenu.add(lineItem = new JRadioButtonMenuItem("Line", true)); 39 elementMenu.add(rectangleItem = new 40 JRadioButtonMenuItem("Rectangle", false)); 41 elementMenu.add(circleItem = new JRadioButtonMenuItem("Circle", 42 false)); 43 elementMenu.add(curveItem = new JRadioButtonMenuItem("Curve", 44 false)); 45 46 ButtonGroup types = new ButtonGroup(); 47 types.add(lineItem); 48 types.add(rectangleItem); 49 types.add(circleItem); 50 types.add(curveItem); 51 52 elementMenu.addSeparator(); 53 54 // to grouping

254


55 JMenu colorMenu = new JMenu("Color"); 56 elementMenu.add(colorMenu); 57 colorMenu.add(redItem = new JCheckBoxMenuItem("Red", false)); 58 colorMenu.add(yellowItem = new JCheckBoxMenuItem("Yellow", false)); 59 colorMenu.add(greenItem = new JCheckBoxMenuItem("Green", false)); 60 colorMenu.add(blueItem = new JCheckBoxMenuItem("Blue", true)); 61 62 menuBar.add(fileMenu); 63 menuBar.add(elementMenu); 64 } 65 }

Contoh 10.8 : /* * Nama File : Sketcher.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.awt.*; 2 import javax.swing.ImageIcon; 3 import java.io.*; 4 import java.net.*; 5 import java.awt.*; 6 7 public class Sketcher{ 8 9 static SketchFrame window; 10 11 public static void main(String[] args){ 12 window = new SketchFrame("Sketcher"); // create application window 13 14 Toolkit theKit = window.getToolkit(); // get the window toolkit 15 Dimension wndSize = theKit.getScreenSize(); // get screen size 16 17 18 try { 19 URL iconUrl = new URL("file", "localhost", "myIcon.jpg"); 20 ImageIcon icon = new ImageIcon(iconUrl); 21 window.setIconImage(icon.getImage()); 22 } 23 catch (Exception e) { /* Not important */ } 24 25 26 // set the position to screen 27 window.setBounds(wndSize.width/4, wndSize.height/4, 28 wndSize.width/2, wndSize.height/2); 29 30 window.setVisible(true); 31 }

255


32 }


Pada contoh 10.7 kita menambahkan suatu menu item pada suatu menu, seperti yang

dinyatakan pada baris 28 sampai 32. Untuk membetuk suatu garis pemisah antara sutu

menu item dengan menu item yang lain, digunakan method addSeparator( ). Untuk

menambahkan suatu menu terhadap suatu menu (menu Elemen mengandung menu Color,

dimana menu Color memilki menu item Red, Yellow, Green, dan Blue) dapat dilakukan

seperti yang dinyatakan pada baris 55 sampai 60. Pada baris 60 kita memberikan nilai

argumen bernilai true, maka elemen menu item blue akan di check list, saat aplikasi ini

dijalankan. Adapun hasil eksekusi dari listing program contoh 10.8 adalah seperti yang


Contoh 10.9:

/* * Nama File : Screengui.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1

256


*/

1 import java.awt.*; 2 import java.awt.event.*; 3 import java.lang.*; 4 import javax.swing.*; 5 import javax.swing.border.*; 6 7 public class Screengui extends JFrame implements ActionListener,KeyListener { 8 Color skyblue = new Color(135,206,235); // preferred GUI color 9 10 //declare file area components 11 JTextArea sourceArea = new JTextArea(10,50); 12 JScrollPane sourcePane = new JScrollPane(sourceArea); 13 JPanel sPanel = new JPanel(); 14 15 JTextArea reportArea = new JTextArea(10,50); 16 JScrollPane reportPane = new JScrollPane(reportArea); 17 JPanel rPanel = new JPanel(); 18 19 JPanel fileZone = new JPanel(new GridLayout(2,1,2,2)); 20 21 //declare button components 22 JButton runButton = new JButton("Run"); 23 JButton clrButton = new JButton("Clear Source"); 24 JButton clr2Button = new JButton("Clear Output"); 25 JButton helpButton = new JButton("Help"); 26 JButton aboutButton = new JButton("About"); 27 JButton exitButton = new JButton("Exit Utility"); 28 JPanel buttons = new JPanel(new GridLayout(6,1,2,2)); 29 30 //main is split into 2 grid regions 31 JPanel main = new JPanel(new BorderLayout()); 32 33 public Screengui() // the gui constructor and initializer 34 { 35 //start with framework 36 super("Screen IO Utility"); 37 setBounds(10,10,750,500); 38 setResizable(false); // 39 setDefaultCloseOperation(DO_NOTHING_ON_CLOSE); 40 41 //construct files/io zone 42 sourceArea.setBackground(Color.white); //set background color 43 sPanel.add(sourcePane); 44 sPanel.setBackground(skyblue); 45 sPanel.setBorder(new TitledBorder("Source")); 46 47 reportArea.setBackground(Color.white); 48 rPanel.add(reportPane); 49 rPanel.setBackground(skyblue); 50 rPanel.setBorder(new TitledBorder("Output"));

257


51 52 fileZone.add(sPanel); 53 fileZone.add(rPanel); 54 fileZone.setBackground(skyblue); 55 fileZone.setBorder(new TitledBorder("Text IO Zone")); 56 57 //construct controls zone 58 buttons.add(runButton); 59 buttons.add(clrButton); 60 buttons.add(clr2Button); 61 buttons.add(helpButton); 62 buttons.add(aboutButton); 63 buttons.add(exitButton); 64 checkWS(); 65 buttons.setBackground(skyblue); 66 buttons.setBorder(new TitledBorder("RunTime Options")); 67 68 //complete the panel assembly 69 main.add("Center",fileZone); 70 main.add("East",buttons); 71 this.getContentPane().add("Center",main); 72 setVisible(true); 73 74 //add the listeners 75 sourceArea.addKeyListener(this); 76 runButton.addActionListener(this); 77 clrButton.addActionListener(this); 78 clr2Button.addActionListener(this); 79 helpButton.addActionListener(this); 80 aboutButton.addActionListener(this); 81 exitButton.addActionListener(this); 82 } 83 84 public void keyReleased(KeyEvent event){checkWS();} // key event handlers 85 public void keyTyped(KeyEvent event){} 86 public void keyPressed(KeyEvent event){} 87 88 public void actionPerformed(ActionEvent event) // action event handler 89 { 90 Object source = event.getSource(); 91 if (source == runButton){ 92 String t = sourceArea.getText().toUpperCase(); // do something 93 reportArea.setText(t); 94 JOptionPane.showMessageDialog(null,"TEst", 95 "Message Dialog",JOptionPane.PLAIN_MESSAGE); 96 checkWS(); // now put it in display area 97 } 98 99 if (source == clrButton){ 100 sourceArea.setText(""); 101 checkWS(); 102 }

258


103 104 if (source == clr2Button){ 105 reportArea.setText(""); 106 checkWS(); 107 } 108 109 if (source == helpButton){ 110 JOptionPane.showMessageDialog(null, 111 "Contact: [email protected] regarding instructions", 112 "Message Dialog",JOptionPane.PLAIN_MESSAGE); 113 } 114 115 if (source == aboutButton){ 116 JOptionPane.showMessageDialog(null, 117 "Screengui version 1.0\nAuthor: Jasman Pardede", 118 "Message Dialog",JOptionPane.PLAIN_MESSAGE); 119 } 120 121 if (source == exitButton){ 122 System.exit(0); 123 } 124 } 125 public void checkWS(){ 126 boolean flag = true; 127 if (sourceArea.getText().length() == 0){ 128 flag=false; 129 } 130 131 runButton.setEnabled(flag); 132 clrButton.setEnabled(flag); 133 134 flag = true; 135 if (reportArea.getText().length() == 0){ 136 flag=false; 137 } 138 clr2Button.setEnabled(flag); 139 } 140 141 public static void main(String[] args){ 142 try { 143 144 UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 145 } 146 catch (Exception e) {;} 147 new Screengui(); 148 } 149 }

259



Pada contoh 10.9 baris 7 meng-implements ActionListener,KeyListener sehingga aksi yang

diberikan oleh pengguna terhadap objek screengui akan diresponi oleh

actionPerformed() seperti yang dinyatakan pada baris 88. Event yang diberikan oleh

pengguna dapat diberikan suatu aksi, karena event tersebut telah kita definisikan

listenernya, seperti yang dinyatakan pada baris 75 sampai 81. Saat suatu aksi dilakukan

oleh pengguna maka event tersebut akan ditanggkap source apa yang sedang melakukan

aksi dengan menggunakan method getSource() Event, seperti yang dinyatakan pada baris

90. Pada baris digunakan 91, 99, 104, 109, 115, dan 121 untuk mencocokkan source yang

melakukan suatu event saat ditangkap oleh suatu listener event. Pada contoh

implementasi aplikasi, pengguna memasukkan kata satu ke dalam text area source,

kemudian pengguna menekan button run, maka aplikasi akan mengambil source yang

bersesuaian adalah runButton pada baris 91. Akibatnya akan mengeksekusi pada baris 92

sampai 96. Pada baris 96 akan memanggil method pada baris 125 dan menampilkan

260


hasilnya ke text area output. Adapun hasil eksekusi dari listing program contoh 10.9


261


Soal Latihan Bab 10. 1. Jelaskan apa yang dimaksud dengan model MVC?

2. Gambarkan dan jelaskan proses penanganan Event pada Swing Java.

3. Apa yang dimaksud dengan shortcut dan berikan contoh program java sederhana dalam

pembuatan suatu shortcut.

4. Pada java terdapat dua kategori event. Jelaskan ke dua kategori tersebut.

5. Buatlah program java sederhana untuk memanpilkan GUI seperti yang ditunjukkan pada

gambar 10.8.

Gambar 10.8 Form Input Data Mhs

262


Bab 11 JDBC

Pada bab ini akan membahas pemrograman Java yang dapat berhubungan dengan

interface database relasional atau suatu databases yang dapat diakses dengan

menggunakan Structured Query Language (SQL) dengan menggunakan class-class yang

ada di JDK pada JDBC API.

JDBC adalah suatu interface untuk menghubungkan data source. Java Database

Connectivity (JDBC) library disediakan dengan maksud untuk pengeksekusian statement

SQL. JDBC didesain sebagai suatu berorientasi objek, API (Application Programming

Interface) berbasis java untuk mengakses source data dan sebagai standar bagi vendor

database dan pengembang Java.

Library JDBC diimplementasikan pada package java.sql, yaitu sekumpulan

classes dan interface yang menyediakan sekumpulan API untuk mengakses database.

11.1 Package JDBC

Library JDBC didesain sebagai suatu interface untuk pengeksekusian statmenent

SQL, dan bukan sebagai abtraksi level tertinggi bagi pengaksesan data. Sehingga,

walaupun JDBC bukan didesain secara otomatis untuk map Java class ke baris-baris pada

suatu database, JDBC memperbolehkan sejumlah aplikasi untuk ditulis pada inteface

JDBC tanpa perlu mencemaskan database mana yang akan digunakan di dalam suatu

aplikasi.

Dari sudut pandang aplikasi Java dapat kita lihat bahwa JDBC berperan sebagai

penghubung antara aplikasi dengan database. Dengan adanya JDBC aplikasi Java akan

dapat mengakses database tertentu. Hubungan antara aplikasi dan suatu Database

Management System dengan suatu JDBC dapat direpresentasikan seperti yang

dinyatakan pada gambar 11.1.

JDBC mengatur suatu pengimplemantasian dari interface JDBC ke suatu database

tertentu, yakni melalui suatu driver. Driver inilah yang mengatur pemetaan method yang

dipanggil class JDBC ke database API.

263


Java Application

JDBC

Sybase Oracle MySQL . . .

Gambar 11.1 Keterhubungan JDBC dengan aplikasi java dan suatu DBMS

11.2 Hubungan JDBC dengan ODBC

Secara umum JDBC sangat mudah digunakan karena JDBC mengimport komponen

konseptual berikut :

1. Driver Manager, meloads database driver, dan mengatur koneksi antara aplikasi

dan driver

2. Driver, mentransformasikan API untuk memanggil operasi pada suatu data source

tertentu.

3. Connection, untuk menciptakan suatu sesi antara suatu aplikasi dengan suatu

database

4. Statement, suatu SQL statement untuk membentuk suatu query atau operasi

update

5. Metadata, informasi tentang pengembalian data, database atau driver

6. Resultset, logical sekumpulan columns dan rows data yang dikembalikan dengan

mengeksekusi suatu statement.

Arsitektur JDBC didasarkan pada sekumpulan interface Java dan classes yang secara

bersamaan untuk menghubungkan ke data source, untuk menciptakan dan mengeksekusi

statement SQL, dan mengambil dan memodifikasi data di dalam database. Operasi

tersebut dapat diilustrasikan seperti yang dinyatakan pada gambar 11.2.

264


Gambar 11.2 Ilustrasi operasi aplikasi java dengan suatu database

11.2.1 DriverManager

Class DriverManager adalah class yang bertanggung jawab di dalam menyusun

koneksi antara data source, diakses melalui JDBC Driver. Jika suatu JDBC driver telah

diidentifikasi di dalam sistem properti “jdbc.driver”, maka class DriverManager akan

berusaha untuk meload driver.

System property secara aktual disimpan di dalam objek Properties, yang

didefinisikan di dalam package java.util, yang berhubungan dengan key di dalam suatu

map, dan kontent dari maps didefinisikan sebagai sekumpulan system properties.

Saudara dapat menset system property “jdbc.driver” dengan memanggil method

setProperty () dari class System, dengan cara berikut :

System.setProperty(“jdbc.driver”, “sun.jdbc.odbc.JdbcOdbcDriver”);

Untuk memasukkan driver yang akan digunakan, saudara dapat meload driver

secara eksplisit dengan memanggil method static forName( )yang berada di dalam class

forName( ). Contoh,

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

Method di dalam DriverManager digunakan untuk menentukan driver apa yang akan

diload. Saat saudara membutuhkan suatu koneksi ke suatu JDBC driver, saudara tidak

perlu mencipatakan suatu objek baru yang membungkus dirinya sendiri-tetapi hanya

meminta DriverManager untuk mencipatakan suatu driver baru.

265


11.2.2 Menciptakan Suatu Koneksi ke Data Source

Koneksi ke suatu data source terntentu direpresentasikan dengan suatu objek dari

class yang mengimplementasikan interface Connection. Sebelum saudara mengeksekusi

suatu statement SQL, saudara pertama sekali harus memiliki suatu objek Connection.

Suatu objek Connection merepresentasikan suatu penyusunan koneksi ke suatu data

source tertentu, kemudian saudara menggunakan objek ini untuk menciptakan suatu

objek Statement yang memiliki kemampuan di dalam mendefinisikan dan mengeksekusi

suatu statement SQL tertentu. Dalam membuat suatu objek Connection dapat dilakukan

dengan cara :

Connection dbConnection = DriverManager.getConnection(source);

Jika saudara perlu menset user dan password DBMS maka dapat dilakukan dengan cara

berikut :

Connection dbConnection = DriverManager.getConnection(source, user, password);

Jika saudara menggunakan properti dapat dilakukan dengan cara berikut :

Properties prop = new Properties( );

prop.setProperty(“user”, “ItisMe”);

prop.setProperty(“password”, “cumatest”);

Connection dbConnection = new DriverManager.getConnection(“database”, prop)

Untuk menspesifikasi periode timeout logging ke dalam suatu database dapat

dilakukan dengan cara menset validasi waktu pengguna dapat loggin yang dapat

dilakukan dengan cara berikut :

Class.forName(driverName);

DriverManager.setLogginTimeout(60);

11.2.3 Statement Object

Suatu objek statement adalah suatu objek dari suatu class yang

mengimplementasikan interface Statement. Saat suatu objek Statement diciptakan, maka

akan menyediakan suatu workspace untuk mencipatakan suatu query SQL, yang dapat

dieksekusi, atau mengembil data dari suatu tabel. Objek Statement dapat diciptakan

dengan cara memanggil method createStatement( ) dari suatu objek Connection. Saat

saudara menciptakan suatu objek statement maka saudara dapat mengeksekusi suatu

266


query dengan menggunakan method executeQuery ( ). Hasil dari pengeksekusian query

akan mengembalikan type ResultSet, seperti yang ditunjukkan pada bagian dibawah ini :

Connection dbConnect = DriverManaget.getConnection(url);

Statement stm = dbConnect.createStatement( );

ResultSet authorNames = stm.executeQuery(“Select firstName, lastName from author”);

11.2.4 ResultSet Object

Hasil dari pengeksekusian suatu query SQL dikembalikan dalam bentuk suatu objek

yang mengimplementasikan interface ResultSet, yaitu mengandung data-data yang

diambil dari tabel yang sedang dieksekusi query SQL. Objek ResultSet memiliki suatu

cursor yang dapat memanipulasi ke suatu baris tertentu dalam resultset. Cursor inilah

yang menginisialisasi posisi pengaksesan baris selanjutnya yang akan diambil datanya,

yaitu dengan cara memanggil method next ( ) dari objek ResultSet. Terdapat beberapa

method di dalam menangani peletakan posisi cursor, yaitu :

1. first ( ) dan last( ), untuk meletakkan posisi cursor pada baris pertama atau baris

terakhir

2. beforeFirst( ) dan afterLast( ), untuk meletakkan posisi cursor pada baris baris

pertama atau setelah baris terakhir.

3. previous( ), untuk memindahkan posisi cursor ke posisi baris sebelumnya dari

posisi cursor saat diakses.

Method next( ) dan previous( ), akan mengembalikan suatu nilai true, jika pemindahan

cursor masih valid. Saudara dapat mengambil semua data dari tabel dengan menggunakan

method berikut di dalam proses looping, seperti yang ditunjukkan berikut :

while(authorNames.next( )){

// proses baris

}

Saudara dapat juga menggunakan method isLast( ) dan isFirst( ) untuk

menentukan apakah posisi cursor berada pada posisi akhir atau posisi awal dari suatu

ResultSet.

267


11.2.5 Pengaksesan Data dalam ResultSet

Gunakan ResultSet untuk mengambil nilai data dari baris atau colum dengan cara

mengambil nilai berdasarkan nama kolom atau posisi kolom. Interface ResultSet

mendeklarasikan beberapa method untuk mengambil nilai data tabel yang sedang diakses

sesuai dengan type data Java, yaitu :

1. getAsciiStream( ), mengambil nilai suatu field dari tabel dengan tipe data Ascii

stream.

2. getBoolean( ), mengambil nilai suatu field dari tabel dengan tipe data boolean.

3. getDate ( ), mengambil nilai suatu field dari tabel dengan tipe data Date.

4. getInt( ), mengambil nilai suatu field dari tabel dengan tipe data int.

5. getShort ( ), mengambil nilai suatu field dari tabel dengan tipe data short.

6. getTimestamp( ), mengambil nilai suatu field dari tabel dengan tipe data time

stamp

7. getBinaryStream( ), mengambil nilai suatu field dari tabel dengan tipe data binary

stream.

8. getBytes( ), mengambil nilai suatu field dari tabel dengan tipe data bytes.

9. getFloat( ), mengambil nilai suatu field dari tabel dengan tipe data float.

10. getObject ( ), mengambil nilai suatu field dari tabel dengan tipe data object.

11. getTime( ), mengambil nilai suatu field dari tabel dengan tipe data time.

12. getString( ), mengambil nilai suatu field dari tabel dengan tipe data string.

13. getByte( ), mengambil nilai suatu field dari tabel dengan tipe data byte.

14. getDouble( ), mengambil nilai suatu field dari tabel dengan tipe data double.

15. getLong( ), mengambil nilai suatu field dari tabel dengan tipe data long.

getDate( ), getTime( ) merupakan method yang mengembalikan type data date dan time.

Jika saudara menggunakan method getInt( ) pada suatu field yang mengakses data

CHAR, maka method tersebut akan memparse nilai char ke dalam bentuk integer. Jika

terjadi kesalahan di dalam mengakses database maka akan melemparkan suatu exception

yaitu SQLException.

268


11.2.6 Meta Data pada suatu ResultSet

Method getMetaData( ) bagi suatu objek Result set akan mengembalikan suatu

objek sebagai suatu type ResultSetMetaData yang membungkus metadata bagi suatu

resultset. Interface ResultSetMetaData mendeklarasikan methods yang memanpukan

untuk mengambil items dari metadata pada suatu resultset.

Method getColumnCount( ) mengembalikan jumlah column resultset dengan type

int. Untuk mengambil nama dan type dari setiap column suatu tabel dapat dilakukan

dengan menggunakan method getColumnName( ) dan getColumnType( ). Nama

column akan dikirimkan sebagai string. Seperti yang ditunjukkan dibawah ini;

1 ResultSetMetaData metadata = result.getMetaData(); 2 int columns = metadata.getColumnCount(); 3 4 System.out.println(); 5 System.out.println("Jumlah kolom : " + columns); 6 7 for(int i=1; i<=columns; i++){ 8 if(metadata.getColumnType(i) == Types.VARCHAR) 9 System.out.println(metadata.getColumnName(i)); 10 else if(metadata.getColumnType(i) == Types.DOUBLE) 11 System.out.println(metadata.getColumnName(i)); 12 else if(metadata.getColumnType(i) == Types.INTEGER) 13 System.out.println(metadata.getColumnName(i)); 14 }

Pada baris 2 dari meta data kita dapat mengambil banyaknya field atau column yang

dimiliki oleh suatu tabel yang kita akses dari suatu database. Pada baris 8, dari metadata

akan mengambil informasi tipe data yang dimiliki oleh meta data, dimana jika tipe

datanya sama dengan Types.VARCHAR, yaitu jika jika tipe data column yang diambil

merupakan tipe data Varchar maka akan mengeksekusi baris 9, akibatnya akan

mengambil nama columnnya. Jika tipe datanya double akan mengeksekusi pada baris ke

10, dan jika tipe datanya int maka akan mengeksekusi pada bars 12.

Pada metadata juga terdapat beberapa method yang dapat digunakan di dalam

interface ResultSetMetaData,

1. getTableName( ), mengembalikan nama table dengan type String

2. getColumnLabel( ), mengembalikan suatu objek String dari nama column suatu

tabel

3. getPrecision( ), mengembalikan nilai desimal pada suatu column

269


4. getColumnDisplaySize( ), mengirimkan jumlah maksimum angka yang dapat

disimpan di dalam suatu column.

11.2.7 PreparedStatement

Objek PreparedStatement sama seperti objek Statement, yang diciptakan dari

objek Connection. Objek Statement diciptakan dari method createStatement dari objek

Connection, sedangkan objek PreparedStatement diciptakan dari method

prepareStatement dari objek Connection, dengan memasukkan query string dalam

method prepareStatment yang akan dieksekusi, seperti yang ditunjukkan dibawah ini;

String queryStr = “Update tb_barang set namabrg = ? where idbarang=?”;

PreparedStatement updateNamaBrg = connectiondb.prepareStatement(queryStr);

updateNameBrg.setString(1, “Gitar”);

updateNamaBrg.setInt(2, 1);

tanda “?” menyatakan nilai yang akan dimasukkan sebagai rujukan pengesetan nilai,

yaitu dengan cara memanggil method yang bersesuaian dengan type datanya. Untuk type

data string menggunakan method setString( ), untuk type integer menggunakan method

setInt( ). Pengisian nilai pada pengesetan method dilakukan dengan cara, bagian pertama

menunjukkan nilai urutan, sedangkan bagian kedua adalah nilai data yang akan

dimasukkan sebagai pengganti “?”. Jadi setString(1, “Gitar”) karena tanda “?” berada di

urutan pertama, sedangkan jika “Gitar” untuk menggantikan namabrg menjadi “Gitar”

pada idbarang yang pengisian urutan kedua, yang kita set dengan setInt(2, 1). Type di

dalam method disesuaikan dengan type data dari tabel yang dibentuk. Karena namabrg

bertype varchar maka digunakan method setString, sedangkan idbarang ber-type integer

maka method yang digunakan setInt( ). Untuk memberikan pemahanan yang lebih jelas

Saudara dapat melihat listing code, seperti yang dinyatakan pada contoh 11.5.

11.3 InteractiveSQL Tool

Sejauh ini, contoh yang ditunjukkan adalah aplikasi console. Dalam prakteknya

saudara ingin mengimplemantasikan aplikasi window interaktif. Untuk

mengimplementasikan aplikasi InteractiveSQL dapat dilakukan dengan menggunakan

270


component swing database aplikasi khusus, yaitu JTable yang didefiniskan di dalam

package javax.swing.table.

Saudara dapat menggunakan component JTable untuk menampilkan data pada

suatu layar. Terdapat beberapa cara untuk menciptakan suatu component JTable, tatepi

pada pembahasan ini hanya memperlihatkan penciptaan JTable secara konvensional,

yakni menggunakan suatu objek yang membungkus data yang ditampilkan dari suatu

tabel dan telah mengimplementasikan interface TableModel, yaitu dengan cara berikut :

JTable tabel = new JTabel(model);

Dimana, model adalah sutu variabel yang memiliki type TableModel.

11. 4 Pengertian Interface TabelModel

Interface TableModel mendeklarasikan methods yang digunakan oleh JTable

untuk mengakses item data. Interface ini didefinisikan pada package javax.swing.table

11.5 Pemanggilan Procedure

Banyak sistem database yang mendukung store procedure. Pada pemrograman

Java telah difasilitasi di dalam pemanggilan store procedure, dimana JDBC menyediakan

dukungan pengaksesan ini dengan menggunakan interface CallableStatemen yang

diturunkan dari interface PreparedStatement. Dalam pengaksesan store procedure dapat

dilakukan dengan memanggil method prepareCall( ) yang berasal dari objek

Connection, seperti yang ditunjukkan dibawah ini;

CallableStatement call = connectiondb.prepareCall( “{call procedureName}”);

ResultSet result = call.executeQuery( );

11.6 Pengaturan Koneksi dengan ODBC

Sebelum kita dapat mengoperasikan method-method yang ada pada package

JDBC, terlebih dahulu kita membuat driver JDBC sesuai dengan DBMS yang akan kita

gunakan, pada pembahasan ini kita menggunakan DBMS MySQL.

271


Urutan langkah pengaturan setting driver JDBC dilakukan seperti langkah-langkah

berikut ini. Setiap langkah diharapkan dilakukan secara benar sehingga menghasilkan

koneksi yang benar dengan DBMS yang akan kita gunakan.

1. Pilih Control Panel, untuk mendapatkan Administrative Tool, seperti yang

ditunjukkan pada gambar dibawah ini, yaitu dari Start -> Setting -> Control Panel.

Seperti yang dinyatakan pada gambar 11.3.

Gambar 11.3 Cara mengakses control panel

2. Pilih Adminstrative Tools dari control panel yaitu cukup dengan meng-click

iconnya seperti yang ditunjukkan pada gambar 11.4.

Gambar 11.4 Icon Administrative tools

3. Pilih Data Source (ODBC) dari administrative tools yaitu cukup dengan meng-

click iconnya seperti yang ditunjukkan pada gambar 11.5.

Gambar 11.5 Icon ODBC

272


4. Buat driver baru dari Data Source Administrator dengan cara meng-click tombol

Add, seperti yang ditunujukkan pada gambar 11.6.

Gambar 11.6 ODBC data source administrative

5. Pilih driver DBMS yang akan kita gunakan, misalkan jika kita menggunakan

DBMS MySQL, kita pilih MySQL ODBS 3.51 Driver, seperti yang ditunjukkan

pda gambar dibawah ini. Perlu diperhatikan bahwa driver MySQL ODBS 3.51

Driver ada jika kita telah meng-instal Connector ODBC 3.51 tersebut. Seperti


Gambar 11.6 Pemilihan driver ODBC MySQL

6. Isi semua data connector ODBC yang diperlukan. Unutk pengisian data source

name diisi dengan nama data source yang akan kita gunakan pada atribut url

Click button Add

Pilih ODBC MySQL

273


koneksi aplikasi ke database. Disini penulis memberikan nama data source

dengan “db_itenas”. Nilai description dapat diisi atau kosong, untuk nilai server

diisi dengan “localhost” atau ip address dimana kita meng-install DBMS MySQL.

Untuk user diisi nilainya dengan user dari DMBS MySQL, password diisi dengan

password yang kita berikan pada MySQL, kemudian pada Database jika kita

memililki beberapada database pada DBMS MySQL kita akan dimunculkan list

database kita. Kita memilihi database yang akan kita gunakan, disini penulis

memilih database itenas. Adapun proses pengisian connector ODBC seperti yang


Gambar 11.7 Pengisian nilai data source dan pemilihan database yang digubakan

7. Langkah ini boleh ditiadakan, tetapi untuk menyakinkan kita akan koneksi yang

telah dibuat benar, kita tekan tombol Test, jika berhasil maka akan ditampilkan

hasil seperti yang ditunjukkan pada gambar 11.8. Jika tidak maka akan

memberikan informasi “SQL_ERROR”. Kegagalam koneksi dengan database

dapat disebabkan oleh beberapa faktor, diantaranya akibat server DBMS belum

dijalankan atau dapat juga disebabkan oleh kesalahan server, atau kesalahan

password. Setelah itu pilih tombol Ok Connector/ODBC.

Pemilihan data base

itenas

274


Gambar 11.8 Pengujian berhasil/tidak koneksi database

8. Pilih tombol Ok, maka akan diperoleh tampilan seperti yang ditunjukkan berikut

pada gambar 11.9. Jika berhasil connector yang kita bentuk maka akan muncul di

ODBC Data Source Administrator name, yang bersesuaian dengan Data Source

Name yang telah kita buat pada langkah 8. Kemudian jika semua telah berjalan

dengan baik, pilih tombol Ok. Sehingga akan terbentuk driver ODBC untuk

DBMS MySQL kita, seperti yang dinyatakan pada gambar 11.9.

Gambar 11.9 Pengujian

Contoh 11.1:

/* * Nama File : MakingTheConnection.java

Tekan Test

Data source yang

terbentuk

275


* Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */ 1 import java.sql.*; 2 3 public class MakingTheConnection{ 4 public static void main(String[] args){ 5 String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; 6 String url = "jdbc:odbc:db_itenas"; 7 8 // Load the driver 9 try{ 10 // Load the driver class 11 Class.forName(driver); 12 13 // Define the data source for the driver 14 Connection databaseConnection = 15 DriverManager.getConnection(url); 16 System.out.println("Koneksi Berhasil"); 17 } 18 catch(ClassNotFoundException cnfe){ 19 System.err.println(cnfe); 20 } 21 catch(SQLException sqle){ 22 System.err.println(sqle); 23 } 24 } 25 }

Pada contoh 11.1 memberikan pemahaman bagi kita bagaimana membuat koneksi pada

suatu data source tertentu. Baris 1 kita meng-import java.sql.*, maksudnya kita

menggunakan class-class yang terdapat pada paket sql. Setiap menggunakan interface

JDBC kita tidak boleh lupa untuk meng-import packege java.sql.*. Baris 5 kita

mendeklarasikan identifier driver dengan nilai "sun.jdbc.odbc.JdbcOdbcDriver". Saat kita

menggunakan driver JDBC maka nilai identifier ini harus selalu diberikan. Pada baris 6

kita memberikan nilai identifier url dengan "jdbc:odbc:db_itenas". Ini dari yang ditandai

dengan garis bawah jdbc:odbc:db_itenas harus sama dengan nama data source yang telah

kita definisikan pada user data source, seperti yang dinyatakan pada gambar 11.9. Baris

11 kita memberikan nama driver kita terhadap class yang saat itu dieksekusi yang

digunakan untuk mengambil nilai driver yang telah kita deklarasikan. Baris 14 dan 15

kita mengambil koneksi yang terbentuk berdasarkan nilai url yang telah kita deklarasikan.

Hasil eksekusi baris 14 dan 15 akan mengembalikan objek Connection. Jika koneksi ke

276


database berhasil maka tidak akan ditangkan suatu eksepsi, sehingga akan mengeksekusi

bari 16. Kerena kita menggunakan class DriverManager dan Connection maka kita haris

mengimport java.sql.*, yang mana akan mengambil class DriverManager dan Connection

yang terdapat pada package sql. Jika terjadi eksepsi terhadap pengaksesan koneksi maka

kesalahan tersebut akan ditangkap oleh SQLException, yang terdapat pada baris 21,

sehingga akan ditampilkan informasi kesalahan dengan cara mengeksekusi baris 22.

Karena saat dijalankan aplikasi terkoneksi dengan data base, sehingga hasil eksekusi

listing code contoh 10.1 adalah seperti yang dinyatakan pada gambar 10.3.


Karena setiap hendak mengesekusi suatu database, terlebih dahulu kita harus selalu

koneksi dengan database tersebut, maka kita akan membuatkan class khusus untuk

membentuk koneksi dan memutuskan koneksi seperti yang dinyatakan pada linsting code

contoh 11.2.

Contoh 11.2:

/* * Nama File : ConnectionManager.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.sql.*;

277


2 3 public class ConnectionManager { 4 private Connection con; 5 6 private String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; 7 private String url = "jdbc:odbc:db_itenas"; 8 9 10 // digunakan untuk menciptakan koneksi 11 public Connection logOn(){ 12 try { 13 //Load JDBC Driver 14 Class.forName( driver ).newInstance(); 15 //Buat object Connection 16 con = DriverManager.getConnection( url, username, password ); 17 }catch(Exception ex){ 18 ex.printStackTrace(); 19 } 20 return con; 21 } 22 // digunakan untuk memutuskan koneksi dengan database 23 public void logOff(){ 24 try { 25 //Tutup Koneksi 26 con.close(); 27 }catch(Exception ex){ 28 ex.printStackTrace(); 29 } 30 } 31 }

Pada listing code contoh 11.2 baris 11 kita membuat method khusus untuk menciptakan

koneksi dengan suatu data source, yang dalam hal ini adalah data source db_itenas. Hasil

koneksi yang terbentuk akan dikembalikan class yang akan menggunakannya dengan tipe

data Connection, seperti yang dinyatakan pada baris 11 dengan pengembalian hasil

seperti pada baris 20. Pada method logOff( ), yang terdapat pada baris 23 digunakan

untuk memutuskan koneksi yang terbentuk.

Contoh 11.3: /* * Nama File : ColumnName.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.sql.*;

278


2 3 public class ColumnName{ 4 5 public static void main(String[] args){ 6 String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; 7 String url = "jdbc:odbc:db_itenas"; 8 9 10 String query = "select * from ortu"; 11 12 // Load the driver 13 try{ 14 // Load the driver class 15 Class.forName(driver); 16 17 // Define the data source for the driver 18 Connection databaseConnection = DriverManager.getConnection(url); 19 20 Statement statement = databaseConnection.createStatement(); 21 ResultSet result = statement.executeQuery(query); 22 23 ResultSetMetaData metadata = result.getMetaData(); 24 int columns = metadata.getColumnCount(); 25 26 System.out.println(); 27 System.out.println("Jumlah kolom : " + columns); 28 29 for(int i=1; i<=columns; i++){ 30 System.out.println(metadata.getColumnName(i) + " : " + 31 metadata.getColumnType(i) ); 32 } 33 34 } 35 catch(ClassNotFoundException cnfe){ 36 System.err.println(cnfe); 37 } 38 catch(SQLException sqle){ 39 System.err.println(sqle); 40 } 41 } 42 }

Pada listing code contoh 11.3 digunakan untuk memberikan pemahaman bagaimana

penggunaan ResultSetMetaData di dalam mengambil nama field dan tipe data dari suatu

tabel tertentu. Pada gambar 11.11 telah diberikan dekripsi data kamus data suatu tabel

ortu, dengan nama field dan masing-masing tipe datanya. Pada baris 11 contoh 11.3

mendeklarasikan String query untuk mengambil tabel ortu . Pada baris 18 kita membuat

koneksi dengan mengembalikan Connection yang akan kita simpan nilainya pada

279


identifier databaseConnection. Hasil koneksi tersebut, kita akan membuat suatu statement

yang hendak kita lakukan dengan cara menggunakan method createStatement() dari objek

Connection yang telah kita dapatkan seperti yang dinyatakan pada baris 20.

Gambar 11.11 Deskripsi tabel ortu.


Perlu diperhatikan bahwa, operasi apapun yang hendak kita lakukan terhadapat suatu

tabel yang terdapat pada suatu database, terlebih dahulu kita harus menciptakan objek

statement, seperti yang telah dijelaskan pada subbab 11.2. Pada baris 21 dapat dilihat

bahwa hasil eksekusi yang kita lakukan akan ditampung pada suatu objek ResultSet.

Pada baris 23, kita akan mengambil informasi metadata dari tabel ortu, dengan cara

menggunakan method getMetaData( ), dari objek result yang kita peroleh pada baris 21.

Baris 24 mengambil informasi banyaknya column yang dimiliki oleh tabel ortu, dengan

cara menggunakan method getColumnCount( ) dari metadata kita. Kemudian akan

280


ditampilkan ke pengguna sesuai dengan informasi yang dimiliki oleh tabel ortu, yang

dinyatakan pada baris 29 samapai 32. Adapun hasil eksekusi listing code contoh 11.3

seperti yang dinyatakan pada gambar 11.12.

Misalkan pada tabel ortu, kita memiliki data seperti yang dinyatakan pada gambar 11.13.

Kemudian kita dimintak untuk mengambil semua record data yang terdapat pada tabel

tersebut, seperti yang akan dijelaskan dengan menggunakan listing code contoh 11.4.

Gambar 11.13 Data yang tersimpan pada tabel ortu

Contoh 11.4: /* * Nama File : MakingAStatement.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.sql.*; 2 public class MakingAStatement{ 3 4 public static void main(String[] args){ 5 String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; 6 String url = "jdbc:odbc:db_itenas"; 7 8 9 String query = "select * from ortu"; 10 11 // Load the driver 12 try{ 13 // Load the driver class 14 Class.forName(driver); 15 16 // Define the data source for the driver 17 Connection databaseConnection = DriverManager.getConnection(url); 18 19 Statement statement = databaseConnection.createStatement(); 20 ResultSet result = statement.executeQuery(query); 21 22 ResultSetMetaData metadata = result.getMetaData(); 23 int columns = metadata.getColumnCount(); 24

281


25 System.out.println(); 26 System.out.println("Jumlah kolom : " + columns); 27 System.out.println("====================================="); 28 System.out.println("Nama : Alamat"); 29 System.out.println("====================================="); 30 while(result.next()){ 31 System.out.print(result.getString("nama")); 32 System.out.print("\t\t\t" + result.getString("alamat")); 33 System.out.println(); 34 } 35 36 } 37 catch(ClassNotFoundException cnfe){ 38 System.err.println(cnfe); 39 } 40 catch(SQLException sqle){ 41 System.err.println(sqle); 42 } 43 } 44 }

Pada baris 9 contoh 11.4 kita menggunakan string query “select * from ortu”, maksudnya

adalah kita hendak mengambil semua data field yang ada pada tabel ortu, yaitu idOrtu,

nama, alamat dan contact. Baris 20 kita menyimpan hasil eksekusi yang kita lakukan

ke pada tabel ortu pada objek result. Baris 30 sampai 34 kita hendak mengambil data

yang telah dieksekusi pada ReseultSet yang terdapat pada identifier result. Pada baris 30

akan tetap mengeksekusi blok while, selama result masih memiliki nilai record dari tabel

ortu atau selama nilai result.next( ) tidak menghasilkan nilai null . Perlu diperhatikan

bahwa pengambilan nilai field dari suatu result harus disesuaikan dengan tipe data yang

akan diambil. Pada baris 31 dan 32, karena tipe data field nama dan alamat bertipe String,

maka pengambilan nilai field-nya dengan menggunakan getString(), seperti yang

dijelaskan pada subbab 11.2.5. Pada baris 21 nilai argument yang diberikan kepada

method getString( ), result.getString("nama"), adalah “nama”. Ini berarti bahwa result

akan mengembalikan nilai nama yang terdapat pada field nama yang dimiliki tabel ortu.

Cara lain yang dapat digunakan untuk mengambil nilai dari suatu field adalah dengan

memberikan nomor field dari suatu tabel. Nomor field dari suatu tabel selalu diawali

dengan nomor 1, kemudian 2, dan seterusnya sesuai dengan pada banyak field.

Berdasarkan gambar 11.13, field nama berada pada nomor yang ke dua, maka baris 31

dapat kita ganti dengan menggunakan System.out.print(result.getString(2)). Adapun hasil

eksekusi dari listing code contoh 11.4, seperti yang ditunjukkan pada gambar 11.14.

282



Contoh 11.5:

/*

* Nama File : PrepareUpdate .java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.sql.*; 2 3 public class PrepareUpdate{ 4 5 public static void main(String[] args){ 6 String driver = "sun.jdbc.odbc.JdbcOdbcDriver" ; 7 String url = "jdbc:odbc:db_itenas" ; 8 9 // Load the driver 10 try{ 11 // Load the driver class 12 Class. forName(driver); 13 14 // Define the data source for the driver 15 Connection databaseConnection = DriverManager. 16 getConnection(url); 17 18 String queryStr = "Update tb_barang set namabrg = ? 19 where idbarang=?"; 20 PreparedStatement updateNamaBrg = 21 databaseConnection.prepareStatement(queryStr); 22 23 updateNamaBrg.setString(1, "Gitar" ); 24 updateNamaBrg.setInt(2, 1); 25

283


26 int rowsUpdated = updateNamaBrg.executeUpdate(); 27 System. out.println( "Row affected : " + rowsUpdated); 28 29 String query = "select * from tb_barang"; 30 Statement statement = 31 databaseConnection.createStatement(); 32 ResultSet result = statement.executeQuery(quer y); 33 34 System. out.println(); 35 36 System. out.println( "==============================" ); 37 System. out.println( "Nama Barang : Harga " ); 38 System. out.println( "==============================" ); 39 while(result.next()){ 40 System. out.print(result.getString( 2)); 41 System. out.print( "\t" + 42 result.getDouble( 3)); 43 System. out.println(); 44 } 45 46 } 47 catch(ClassNotFoundException cnfe){ 48 System. err.println(cnfe); 49 } 50 catch(SQLException sqle){ 51 System. err.println(sqle); 52 } 53 } 54 }

Gambar 11.15 Menampilkan data tb_barang dalam MySQL

Contoh 11.5 kita menggunakan tabel tb_barang pada DBMS MySQL seperti yang

ditunjukkan pada gambar 11.15. Pada baris 18 dan 19 contoh 11.5 kita mendeklarasikan

284


String queryStr untuk digunakan pada prepared stamenent. Pada baris 20 dan 21, kita

mendeklarasikan indentifier updateNamaBrg dengan PreparedStatement, yang

diperoleh dari hasil eksekusi method prepareStatement dari objek connection dengan

nilai argument queryStr yang telah dideklarasikan pada baris 18. Pada baris 23 kita

memberikan nilai index pertama dengan nilai “Gitar” yaitu dengan cara memanggil

method setString(1, “Gitar”) dari objek updateNamaBrg. Pemberian nomor indeks

diperoleh dari urutan tanda “?” dimana tanda “?” pertama adalah namabrg dengan

namabrg pada tipe data field tabel tb_barang adalah varchar, maka tipe data yang

digunakan adalah setString. Karena idBarang pada queryStr berada indeks yang kedua

dan tipe data idbarang pada field tabel tb_barang bertipe int, maka untuk pemberian

nilainya seperti yang dinyatakan pada baris 24. Baris 26 memintak objek updateNamaBrg

untuk mengekseksui nilai yang kita berikan pada tabel dan memberikan informasi jumlah

baris yang telah di-update. Baris 29 kita hendak menampilkan hasil peng-update-an tabel,

dengan menggunakan listing code baris 40, 41, dan 42. Karena namabrg berada pada

kolom kedua dari tb_barang, maka dapat diambil dengan menggunakan method seperti

pada baris 40. Adapun hasil eksekusi dari listing code contoh 11.5, seperti yang

ditunjukkan pada gambar 11.16. Hasil eksekusi DBMS MySQL dapat dinyatakan seperti



285


Gambar 11.17 Menampilkan hasil update tb_barang dalam MySQL

Contoh 11.6:

1 String queryStr = "Update tb_barang set namabrg = 'Gitar' " + 2 "where idbarang=1" ; 3 Statement updateNamaBrg = databaseConnection.cr eateStatement(); 4 int rowsUpdated = updateNamaBrg.executeUpdate(queryStr );

Penulisan listing code Contoh 11.5 baris 18 sampai 26, dapat kita gantikan dengan baris 1

sampai 4 listing code contoh 11.6. Perbedaan keduanya terletak pada cara pemberian

nilainya. Pada contoh 11.5, kita memberikan nilainya saat kita hendak mengeksekusinya

sedangkan pada contoh 11.6 nilainya sejak awal sudah diberikan.

Contoh 11.7:

/* * Nama File : DataSearch.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import javax.swing.*; 2 import java.awt.*; 3 import javax.swing.border.*; 4 import java.awt.event.*; 5 import java.sql.*; 6 import java.io.*; 7 import java.util.*; 8

Update nama barang Piano menjadi Gitar,

yaitu yang memiliki

idbarang=1

286


9 public class DataSearch extends JFrame implements ActionListener{ 10 private Connection con; 11 private ConnectionManager conMan = new ConnectionManager(); 12 private Statement stmt; 13 private ResultSet rs; 14 private JTextField namaBarang = new JTextField(6); 15 private JTextField hargaBarang = new JTextField(10); 16 private JTextField kategori = new JTextField(2); 17 private JTextField idBarang = new JTextField(2); 18 private JButton btnSave = new JButton("Save"); 19 private JButton btnSearch = new JButton("Search"); 20 private JButton btnCancel = new JButton("Cancel"); 21 private JButton btnReset = new JButton("Reset"); 22 private JButton btnCapture = new JButton("Capture"); 23 24 public static void main(String[] args){ 25 DataSearch theApp = new DataSearch(); 26 } 27 28 public DataSearch(){ 29 super("Database Browser"); 30 setBounds(0, 0, 400, 300); 31 setDefaultCloseOperation(DISPOSE_ON_CLOSE); 32 addWindowListener(new WindowHandler()); 33 JPanel panel = new JPanel(new GridBagLayout()); 34 JPanel panelEvent = new JPanel(); 35 // create Label for input fields 36 JLabel namaBrgLabel = new JLabel("Nama Barang :"); 37 JLabel hargaBrgLabel = new JLabel("Harga Barang :"); 38 JLabel kategoriLabel = new JLabel("Kategori :"); 39 JLabel idBarangLabel = new JLabel("ID Barang :"); 40 // set same size 41 hargaBrgLabel.setPreferredSize(namaBrgLabel.getPreferredSize()); 42 43 panel.add(namaBrgLabel,new SetConstraints(0, 0, 1, 1, 1.0, 1.0, 44 GridBagConstraints.NORTHWEST, 45 GridBagConstraints.BOTH, 46 new Insets(0, 0, 0, 0), 0, 0)); 47 panel.add(namaBarang, new SetConstraints(1, 0, 1, 1, 1.0, 1.0, 48 GridBagConstraints.NORTHWEST, 49 GridBagConstraints.BOTH, 50 new Insets(0, 0, 0, 0), 0, 0)); 51 52 panel.add(hargaBrgLabel, new SetConstraints(0, 1, 1, 1, 1.0, 1.0, 53 GridBagConstraints.NORTHWEST, 54 GridBagConstraints.BOTH, 55 new Insets(0, 0, 0, 0), 0, 0)); 56 panel.add(hargaBarang, new SetConstraints(1, 1, 1, 1, 1.0, 1.0, 57 GridBagConstraints.NORTHWEST, 58 GridBagConstraints.BOTH, 59 new Insets(0, 0, 0, 0), 0, 0)); 60

287


61 panel.add(kategoriLabel, new SetConstraints(0, 2, 1, 1, 1.0, 1.0, 62 GridBagConstraints.NORTHWEST, 63 GridBagConstraints.BOTH, 64 new Insets(0, 0, 0, 0), 0, 0)); 65 panel.add(kategori, new SetConstraints(1, 2, 1, 1, 1.0, 1.0, 66 GridBagConstraints.NORTHWEST, 67 GridBagConstraints.BOTH, 68 new Insets(0, 0, 0, 0), 0, 0)); 69 panel.add(idBarangLabel, new SetConstraints(0, 3, 1, 1, 1.0, 1.0, 70 GridBagConstraints.NORTHWEST, 71 GridBagConstraints.BOTH, 72 new Insets(0, 0, 0, 0), 0, 0)); 73 panel.add(idBarang, new SetConstraints(1, 3, 1, 1, 1.0, 1.0, 74 GridBagConstraints.NORTHWEST, 75 GridBagConstraints.BOTH, 76 new Insets(0, 0, 0, 0), 0, 0)); 77 78 // Panel Event 79 Dimension size = new Dimension(60, 20); 80 Border edge = BorderFactory.createRaisedBevelBorder(); 81 panelEvent.add(btnSave); 82 btnSave.setBorder(edge); 83 btnSave.setPreferredSize(size); 84 85 panelEvent.add(btnSearch); 86 btnSearch.setBorder(edge); 87 btnSearch.setPreferredSize(size); 88 89 panelEvent.add(btnCancel); 90 btnCancel.setBorder(edge); 91 btnCancel.setPreferredSize(size); 92 93 panelEvent.add(btnReset); 94 btnReset.setBorder(edge); 95 btnReset.setPreferredSize(size); 96 97 panelEvent.add(btnCapture); 98 btnCapture.setBorder(edge); 99 btnCapture.setPreferredSize(size); 100 101 HandlerButtonFoto handlerFoto = new HandlerButtonFoto() ; 102 btnCapture.addActionListener(handlerFoto) ; 103 104 getContentPane().add(panel, BorderLayout.CENTER); 105 getContentPane().add(panelEvent, BorderLayout.SOUTH); 106 107 setVisible(true); 108 show(); 109 btnReset.addActionListener(this); 110 btnCancel.addActionListener(this); 110 btnSave.addActionListener(this); 111 btnSearch.addActionListener(this);

288


112 //btnCapture.adActionListener(this); 113 } 114 115 public void actionPerformed(ActionEvent event) // action event handler 116 { 117 Object source = event.getSource(); 118 119 if (source == btnReset){ 120 emptyTextField(); 121 JOptionPane.showMessageDialog(null,"Data tidak disimpan", 122 "Message Dialog",JOptionPane.PLAIN_MESSAGE); 123 } 124 if (source == btnCancel){ 125 dispose(); 126 System.exit(0); 127 } 128 129 if (source == btnSave){ 130 String namaBrg = namaBarang.getText(); 131 String hargaBrg = hargaBarang.getText(); 132 String kategoriBrg = kategori.getText(); 133 String _idBarang = idBarang.getText(); 134 135 JOptionPane.showMessageDialog(null,"Nama Barang : " + namaBrg + " 136 Harga Barang : " + hargaBrg + " Kategori : " + 137 kategoriBrg,"Message Dialog", 138 JOptionPane.PLAIN_MESSAGE); 139 insertBarang(namaBrg, hargaBrg, kategoriBrg, _idBarang); 140 } 141 142 if (source == btnSearch){ 143 String idBrg = idBarang.getText(); 144 int id = Integer.parseInt(idBrg); 145 System.out.println("Ini nilai yg dicari : " + id); 146 searchBarang(id); 147 148 } 149 } 150 151 public void connect() { 152 try { 153 con = conMan.logOn(); 154 } 155 catch(Exception ex){ 156 ex.printStackTrace(); 157 } 158 } 159 160 public void disconnect() { 161 try { 162 conMan.logOff(); 163 }

289


164 catch(Exception ex){ 165 ex.printStackTrace(); 166 } 167 } 168 169 public void searchBarang(int _idBrg){ 170 171 try { 172 connect(); 173 174 String queryStr = "select * from tb_barang where idbarang=" + _idBrg; 175 Statement statement = con.createStatement(); 176 ResultSet result = statement.executeQuery(queryStr); 177 178 while(result.next()){ 179 namaBarang.setText(result.getString("namaBrg")); 180 hargaBarang.setText(result.getString("harga")); 181 kategori.setText(result.getString("idkategori")); 182 } 183 disconnect(); 184 }catch(SQLException ex) { 185 ex.printStackTrace(); 186 } 187 catch(Exception ex) { 188 ex.printStackTrace(); 189 } 190 } 191 192 public boolean insertBarang(String _brg, String _harga, String _kategori, String _id) { 193 194 boolean bReg; // = true; 195 196 try { 197 198 //int iTopicID = getNewTopicID() + 1; 199 StringBuffer sBuf = new StringBuffer(); 200 201 sBuf.append("INSERT INTO tb_barang (namabrg, harga, 202 idkategori,idbarang) VALUES ('"); 203 sBuf.append(_brg); 204 sBuf.append("','"); 205 sBuf.append(_harga); 206 sBuf.append("', '"); 207 sBuf.append(_kategori); 208 sBuf.append("', "); 209 sBuf.append(Integer.parseInt(_id)); 210 sBuf.append(")"); 211 String sql = sBuf.toString(); 212 213 connect(); 214 stmt = con.createStatement(); 215 bReg = stmt.execute(sql);

290


216 disconnect(); 217 return bReg = true; 218 219 } 220 catch(SQLException ex) { 221 ex.printStackTrace(); 222 return bReg = false; 223 } 224 catch(Exception ex) { 225 ex.printStackTrace(); 226 return bReg = false; 227 } 228 } 229 230 public boolean insertBarang() { 231 232 boolean bReg; // = true; 233 try { 234 234 //int iTopicID = getNewTopicID() + 1; 235 StringBuffer sBuf = new StringBuffer(); 236 237 sBuf.append("INSERT INTO tb_barang (namabrg, harga, idkategori) 238 VALUES ('Pet', 100, bu)"); 239 String sql = sBuf.toString(); 240 241 connect(); 242 stmt = con.createStatement(); 243 bReg = stmt.execute(sql); 244 disconnect(); 245 return bReg = true; 246 247 } 248 catch(SQLException ex) { 249 ex.printStackTrace(); 250 return bReg = false; 251 } 252 catch(Exception ex) { 253 ex.printStackTrace(); 254 return bReg = false; 255 } 256 } 257 257 public void emptyTextField(){ 258 namaBarang.setText(""); 259 hargaBarang.setText(""); 260 kategori.setText(""); 261 } 262 263 // inner class defining handler for window events 264 class WindowHandler extends WindowAdapter{ 265

291


266 // Handler for window closing event 267 public void windowClosing(WindowEvent e){ 268 dispose(); 269 System.exit(0); 270 } 271 } 272 273 private class HandlerButtonFoto implements ActionListener 274 { 275 public void actionPerformed(ActionEvent action) 276 { 277 Runtime run = Runtime.getRuntime() ; 278 try 279 { 280 run.exec("C:/WINDOWS/amcap.exe") ; 281 } 282 catch(Exception e) 283 { 284 JOptionPane.showMessageDialog(null , "Gagal , 285 Applikasi Gagal Ditemukan" , "Error" , 286 JOptionPane.ERROR_MESSAGE); 287 } 288 } 289 } 290 }

Pada contoh 11.7 kita hendak mengeksekusi suatu tabel dengan menggunakan GUI.

Saudara yang belum memahami tentang pembuatan GUI aplikasi java, dapat membaca

tentang cara pembuatan GUI pada bab 10. Saat menjalankan aplikasi ini maka akan

menampilkan Frame seperti yang dinyatakan pada gambar 11.18. Pengguna memasukkan

nilai-nilai yang bersesuaian yang hendak disimpan pada tabel tb_barang. Ketika

pengguna menekan button Save maka event tersebut akan di-listen dan dikirimkan ke

actionPerformed untuk dichek pengguna sedang menggunakan source btnSave seperti

yang dinyatakan pada baris 129. Ketika baris 139 dieksekusi maka akan memintak

method insertBarang yang terdapat pada bari 192. Ketika pengguna menekan button

Search, maka aksi pengguna akan ditanggapi oleh actionPerformed seperti yang

dinyatakan pada baris 142. Pada baris 143, sistem akan mengambil idBarang yang

dimasukkan pengguna. Saat baris 146 dieksekusi maka akan memanggil method

searchBarang yang terdapat pada baris 169. Pada baris 178 sampai 182 menintak sistem

akan menampilkan hasil eksekusi pengambilan data yang sesuai dengan idBarang yang

dimasukkan pengguna ke text field yang bersesuaian. Pada baris 183 menutup koneksi

dengan database. Ketika pengguna menekan button Reset maka aksi actionPerformed

292


akan mengeksekusi baris 119 kemudian mengeksekusi baris 120. Saat mengeksekusi

baris 120, sistem akan memintak method emptyTextField(), yang terdapat pada baris 257.

Pada baris 257 sampai 260, memintak sistem untuk mengosongkan nilai dari text field,

yaitu dengan cara memberikan nilai dengan string kosong. Adapun hasil eksekusi listing

code 11.7 seperti yang dinyatakan pada gambar 11.18.


Contoh 11.8:

/* * Nama File : InteractiveSQL.java * Programmer : @ author Jasman Pardede * Deskripsi : Program sederhana Java * @version 1.1 */

1 import java.sql.*; // For JDBC class 2 import java.awt.*; // for window class 3 import java.awt.event.*; // for event class 4 import javax.swing.*; // for swing component 5 import javax.swing.table.*; // for the table classes 6 import java.io.*; 7 import java.util.*;

293


8 9 public class InteractiveSQL extends JFrame implements ActionListener{ 10 11 Connection connection; // Connection to the Database 12 Statement statement; // Statement object for queries 13 ResultModel model; // Table model for result set 14 15 JTextField command = new JTextField(); // Input area for SQL 16 JTextArea status = new JTextArea(3, 1); // Output area for status and error 17 JScrollPane resultPane ; 18 19 JMenuBar menuBar = new JMenuBar(); // The Menu Bar 20 JMenuItem clearQueryItem = new JMenuItem("Clear query"); // Clear SQL item 21 JMenuItem exitItem = new JMenuItem("Exit"); // Exit item 22 23 public static void main(String[] args){ 24 String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; 25 String url = "jdbc:odbc:db_itenas"; 26 27 28 29 InteractiveSQL theApp = new InteractiveSQL(driver, url, user, pswd); 30 } 31 32 public InteractiveSQL(String _driver, String _url, String _user, String _pswd){ 33 super("InteractiveSQL"); 34 setBounds(0, 0, 400, 300); 35 setDefaultCloseOperation(DISPOSE_ON_CLOSE); 36 addWindowListener(new WindowHandler()); // listener for window close 37 38 // add input for SQL statament at the top 39 command.setToolTipText("Key SQL Command and press Enter"); 40 getContentPane().add(command, BorderLayout.NORTH); 41 42 // add the status reporting area at the bottom 43 status.setLineWrap(true); 44 status.setWrapStyleWord(true); 45 getContentPane().add(status, BorderLayout.SOUTH); 46 47 // create the menu bar for menu items 48 JMenu fileMenu = new JMenu("File"); // Create File Menu 49 fileMenu.setMnemonic('F'); // create shortcut 50 fileMenu.add(clearQueryItem); // add clear query item 51 fileMenu.add(exitItem); // add exit item 52 menuBar.add(fileMenu); // add menu to menubar 53 setJMenuBar(menuBar); // add menubar to the window 54 55 command.addActionListener(this); 56 clearQueryItem.addActionListener(this); 57 exitItem.addActionListener(this); 58 59 // Establih a database connection and set up the table

294


60 try{ 61 Class.forName(_driver); 62 connection = DriverManager.getConnection(_url, _user, _pswd); 63 statement = connection.createStatement(); 64 65 model = new ResultModel(); // Create a table model 66 JTable table = new JTable(model); // Create table from the model 67 table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 68 resultPane = new JScrollPane(table); // create scrollpane for table 69 getContentPane().add(resultPane, BorderLayout.CENTER); 70 }catch(ClassNotFoundException cnfe){ 71 System.err.println(cnfe); 72 }catch(SQLException sqle){ 73 System.err.println(sqle); 74 } 75 76 pack(); 77 setVisible(true); 78 } 79 80 public void actionPerformed(ActionEvent e){ 81 82 Object source = e.getSource(); 83 84 if(source == command){ 85 executeSQL(); // Enter key for text field item 86 }else if(source == clearQueryItem){ 87 command.setText(""); // clear query menu item 88 }else if(source == exitItem){ 89 dispose(); // release the window resources 90 System.exit(0); // end the application 91 } 92 } 93 94 95 public void executeSQL(){ 96 String query = command.getText(); // get the SQL statement 97 98 if(query== null) // if there's nothing we are done 99 return; 100 101 try{ 102 model.setResultSet(statement.executeQuery(query)); 103 status.setText("Resultset has " + model.getRowCount() + " rows."); 104 }catch(SQLException sqle){ 105 status.setText(sqle.getMessage()); 106 } 107 } 108 109 class WindowHandler extends WindowAdapter{ 110 // Handler for window closing event 111 public void windowClosing(WindowEvent e){

295


112 dispose(); 113 System.exit(0); 114 } 115 } 116 }


Pada baris 65 contoh 11.8 kita menciptakan objek resultModel yang nilainya kita

masukkan ke dalam objek tabel seperti yang dinyatakan pada baris 66. Baris 67

digunakan untuk mengatur pengaturan ukuran agar setiap field tidak dapat diubah-ubah.

Baris 68 digunakan untuk mengaktifkan scroll didalam melihat data berdasarkan record

dari atas ke bawah. Jika penggunakan telah memasukkan suatu query tertentu, kemudian

menekan tombol ENTER, maka akan mengeksekusi pada baris 85, yang akan memintak

method yang terdapat pada baris blok 95 sampai 107. Baris 96 mengambil String query

yang kita masukkan kedalam text field command. Pada baris 102, akan mengeksekusi

query yang kita masukkan ke dalam text field command, kemudian akan dimasukkan ke

dalam objek model dengan menggunakan method setResultSet( ). Adapun hasil eksekusi

listing code 11.8 seperti yang dinyatakan pada gambar 11.19.

296


Soal Latihan Bab 11. 1. Apa yang dimaksud dengan JDBC?

2. Jelaskan urutan langkah-langkah di dalam membuat koneksi JDBC-ODBC dengan data

source “soal”, untuk mengakses database oopJDBC?

3. Jelaskan kegunaan dari ResultSetMetaData?

4. Jelaskan kegunaan dari ResultSet?

5. Diberikan potongan listing code sebagai berikut :

String queryStr = “Update tb_barang set hargabrg = ? where idbarang=?”; PreparedStatement updateNamaBrg= connectiondb.prepareStatement(queryStr); updateNameBrg.setString(1, 76.1); updateNamaBrg.setInt(2, 9); int rowsUpdated = updateNamaBrg.executeUpdate(); System. out.println( "Row affected : " + rowsUpdated);

6. Jelaskan hasil eksekusi dari listing code diatas jika deskripsi tabelnya seperti yang

dinyatakan pada gambar 11.20.

Gambar 11.20 Deskripsi tabel tb_barang

7. Buatlah program java sederhana berbasis GUI untuk memfasilitasi pengguna di dalam

menyimpan data mahasiswa seperti yang ditunjukkan pada gambar 11.21. Saat

pengguna menekan button Simpan akan menyimpan data yang dimaksukan pengguna

ke tabel tbl_mhs, dengan deskripsi tabel seperti yang ditunjukkan pada gambar 11.22.

297


Gambar 11.21 Form Input Data Mhs

Gambar 11.22 Deskripsi tabel tbl_mhs

298


Daftar Pustaka 1. Poo, D., Kiong, D., Ashok, S., (2008), Object-Oriented Programming and Java, Second

Edition, Springer-Verlag, London.

2. Garrido., J., M., (2003), Object-Oriented Programming : From Problem Solving toJava,

Charles River Media, Inc.Hingham, Massachusetts.

3. Wampler,E., B., The Essence of Object Oriented Programming with Java and UML.

4. Reed, R., P., (2001), Developing Applications with JavaTM

and UML, Addison Wesley.

5. Borror, J., A., (1999), Java Principles of Object-Oriented Programming, Miller Freeman,

Inc. Lawrence, USA.

diktat oop mi politekniktelkom by jasman...

Documents