Lembar Pengesahan

Saya yang bertanda tangan di bawah ini:

Nama : Afandi Nur Aziz Thohari

NIP : 17900089
Dosen PJMP : Praktikum Pemrograman Berorietasi Objek
KK : Rekayasa Perangkat Lunak
Menerangkan dengan sesungguhnya bahwa modul ini digunakan untuk pelaksanaan praktikum di
semester ganjil tahun ajaran 2018/2019 di Program Studi S1 Rekayasa Perangkat Lunak Institut
Teknologi Telkom Purwokerto.

Purwokerto, September 2018

Mengesahkan, Mengetahui,

Dosen Pengampu Praktikum Kaprodi S1 Rekayasa Perangkat

Pemrograman Berorientasi Objek Lunak

Afandi Nur Aziz Thohari, S.T., M.Cs Andika Elok Amalia, S.T., M.T
NIDN. 0611049002 NIDN. 0610029001

Modul Praktikum PBO 1

 Peraturan Praktikum
Pemrograman Berorientasi Objek 2018/2019

1. Praktikum diampu oleh dosen kelas dan dibantu oleh asisten praktikum.
2. Praktikum dilaksanakan di Gedung Digital Convergence (DC) sesuai jadwal yang ditentukan.
3. Praktikan wajib membawa modul praktikum, kartu praktikum, dan alat tulis.
4. Praktikan wajib mengisi daftar hadir rooster dan BAP praktikum dengan bolpoin bertinta hitam.
5. Durasi kegiatan praktikum 1 Sks = 100 menit.
a. 20 menit untuk pengerjaan Tes Awal (Pre-Test)
b. 80 menit untuk penyampaian materi
6. Jumlah pertemuan praktikum:
• 8 kali di lab (praktikum rutin)
• 3 kali di luar lab (terkait Tugas Besar dan UAS)
• 1 kali berupa presentasi Tugas Besar atau pelaksanaan UAS
7. Praktikan wajib hadir minimal 75% dari seluruh pertemuan praktikum di lab. Jika total kehadiran
kurang dari 75% maka nilai UAS/ Tugas Besar = 0.
8. Praktikan yang datang terlambat :
• <= 30 menit : diperbolehkan mengikuti praktikum tanpa tambahan waktu Tes Awal
• > 30 menit : tidak diperbolehkan mengikuti praktikum
9. Saat praktikum berlangsung, asisten praktikum dan praktikan:
• Wajib menggunakan seragam sesuai aturan institusi.
• Wajib mematikan/ mengkondisikan semua alat komunikasi.
• Dilarang membuka aplikasi yang tidak berhubungan dengan praktikum yang berlangsung.
• Dilarang mengubah pengaturan software maupun hardware komputer tanpa ijin.
• Dilarang membawa makanan maupun minuman di ruang praktikum.
• Dilarang memberikan jawaban ke praktikan lain.
• Dilarang menyebarkan soal praktikum.
• Dilarang membuang sampah di ruangan praktikum.
• Wajib meletakkan alas kaki dengan rapi pada tempat yang telah disediakan.
10. Setiap praktikan dapat mengikuti praktikum susulan maksimal dua modul untuk satu mata kuliah
praktikum.
• Praktikan yang dapat mengikuti praktikum susulan hanyalah praktikan yang memenuhi syarat
sesuai ketentuan institusi, yaitu: sakit (dibuktikan dengan surat keterangan medis), tugas dari
institusi (dibuktikan dengan surat dinas atau dispensasi dari institusi), atau mendapat musibah
atau kedukaan (menunjukkan surat keterangan dari orangtua/wali mahasiswa.)
• Persyaratan untuk praktikum susulan diserahkan sesegera mungkin kepada asisten laboratorium
untuk keperluan administrasi.
• Praktikan yang diijinkan menjadi peserta praktikum susulan ditetapkan oleh Asman Lab dan
Bengkel Informatika dan tidak dapat diganggu gugat.
11. Pelanggaran terhadap peraturan praktikum akan ditindak secara tegas secara berjenjang di lingkup
Kelas, Laboratorium, Fakultas, hingga Universitas.

Modul Praktikum PBO 2

 DAFTAR ISI

Lembar Pengesahan .................................................................................................................................... 1

Peraturan Praktikum Pemrograman Berorientasi Objek 2018/2019 .......................................................... 2

DAFTAR ISI .................................................................................................................................................. 3

Modul 1 : PENGENALAN JAVA ................................................................................................................. 7

1.1 Tujuan ........................................................................................................................................ 7

1.2 Pengenalan Java .......................................................................................................................... 8

1.2.1 Sejarah singkat Java ............................................................................................................ 8

1.2.2 Karakteristik Java................................................................................................................. 8

1.2.3 Garbage Collection .............................................................................................................. 8

1.3 Instalasi Netbeans ....................................................................................................................... 9

1.3.1 Instalasi JDK (Java Development Kit) ................................................................................... 9

1.3.2 Netbeans ........................................................................................................................... 10

1.4 Tipe Data, Variabel, dan Konstanta ........................................................................................... 11

1.4.1 Tipe data dan Variabel ...................................................................................................... 11

1.4.2 Konstanta .......................................................................................................................... 12

1.5 Variabel Array ........................................................................................................................... 12

1.5.1 Deklarasi variabel array ..................................................................................................... 13

1.5.2 Mengakses variable array.................................................................................................. 13

1.5.3 Array 2 Dimensi ................................................................................................................. 14

1.6 Operator,Pernyataan Kondisional, dan Perulangan .................................................................. 14

1.6.1 Operator ............................................................................................................................ 14

1.6.2 Pernyataan kondisional ..................................................................................................... 16

Modul Praktikum PBO 3

 1.6.3 Perulangan ........................................................................................................................ 18

Modul 2 : Konsep Dasar Pemrograman Berorientasi Objek .................................................................. 20

2.1 Tujuan ....................................................................................................................................... 20

2.2 Pendahuluan ............................................................................................................................. 20

2.2.1 Abstraksi............................................................................................................................ 20

2.2.2 Enkapsulasi........................................................................................................................ 20

2.2.3 Pewarisan (Inheritance) .................................................................................................... 21

2.2.4 Reuseability ....................................................................................................................... 21

2.2.5 Polymorphisms .................................................................................................................. 21

2.2.6 Message (Komunikasi antar objek) ................................................................................... 22

2.3 Kelas .......................................................................................................................................... 22

2.3.1 Object ................................................................................................................................ 23

2.3.2 Java Modifier ..................................................................................................................... 23

2.4 Field .......................................................................................................................................... 26

2.5 Method ..................................................................................................................................... 27

2.6 keyword “this” .......................................................................................................................... 29

2.7 Constructor ............................................................................................................................... 30

Modul 3 : AGREGASI DAN KOMPOSISI ................................................................................................... 33

3.1 Tujuan ....................................................................................................................................... 33

3.2 Diagram Kelas ........................................................................................................................... 33

3.3 Hubungan Antar Kelas ............................................................................................................... 34

3.3.1 Asosiasi.............................................................................................................................. 34

3.3.2 Agregasi............................................................................................................................. 35

3.3.3 Komposisi .......................................................................................................................... 36

Modul 4 : INHERITANCE DAN POLYMORFISME ..................................................................................... 38

Modul Praktikum PBO 4

 4.1 Tujuan ....................................................................................................................................... 38

4.2 Pendahuluan ............................................................................................................................. 38

4.3 Inheritance ................................................................................................................................ 38

4.4 Polymorfisme ............................................................................................................................ 39

4.4.1 Overloading method ......................................................................................................... 40

4.4.2 Overriding method ............................................................................................................ 41

4.5 Referensi Variabel Casting ........................................................................................................ 41

Modul 5 : INTERFACE DAN ABSTRACT ................................................................................................... 46

5.1 Tujuan ....................................................................................................................................... 46

5.2 Interface .................................................................................................................................... 46

5.3 Kelas Abstrak ............................................................................................................................. 49

5.4 Keyword super .......................................................................................................................... 52

Modul 6 : Inner Class, Collection, dan Generics ............................................................................. 54

6.1 Tujuan ....................................................................................................................................... 54

6.2 Inner Class ................................................................................................................................. 54

6.2.1 Mendefinisikan Inner Class ............................................................................................... 55

6.3 Collection .................................................................................................................................. 57

6.3.1 Melakukan Sorting pada Collection ................................................................................... 60

6.3.2 Melakukan Filtering pada Collection ................................................................................. 62

6.4 Generics .................................................................................................................................... 63

Modul 7 : Graphical User Interface (GUI) .............................................................................................. 66

7.1 Tujuan ....................................................................................................................................... 66

7.2 AWT and Swing ......................................................................................................................... 66

7.3 AWT components ...................................................................................................................... 66

7.4 Swing components .................................................................................................................... 66

Modul Praktikum PBO 5

 7.5 Komponen utama dalam GUI .................................................................................................... 66

7.6 The Basic User Interface Components with Swing .................................................................... 67

7.7 Top Level Container .................................................................................................................. 67

7.8 Pengaturan Layout: ................................................................................................................... 68

7.8.1 Pengaturan dengan BorderLayout .................................................................................... 68

7.8.2 Pengaturan dengan BoxLayout ......................................................................................... 69

7.8.3 Pengaturan dengan CardLayout ........................................................................................ 70

7.8.4 Pengaturan dengan FlowLayout ........................................................................................ 70

7.8.5 Pengaturan dengan GridLayout......................................................................................... 71

7.8.6 Pengaturan dengan GridBagLayout ................................................................................... 72

7.8.7 Pengaturan dengan GroupLayout ..................................................................................... 73

7.8.8 Pengaturan dengan SpringLayout ..................................................................................... 75

7.9 Event Handling .......................................................................................................................... 75

Modul 8 : JDBC ...................................................................................................................................... 78

8.1 Tujuan ....................................................................................................................................... 78

8.2 Pendahuluan ............................................................................................................................. 78

8.3 JDBC (Java Database Connectivity)............................................................................................ 81

8.3.1 Inisialisasi Driver ................................................................................................................ 82

8.3.2 Koneksi Ke Database dengan menggunakan URL .............................................................. 82

8.3.3 Penggunaan Database ....................................................................................................... 82

8.3.4 Mengakhiri Koneksi ........................................................................................................... 83

Buku Pendukung ....................................................................................................................................... 88

Modul Praktikum PBO 6

 Modul 1 : PENGENALAN JAVA

1.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat:
1. Mengetahui dan mengenal bahasa pemrograman java
2. Mengetahui cara instalasi dan konfigurasi java
3. Memahami tipe data, variabel, konstanta dan dapat mengimplementasikannya dalam
pemrograman java.
4. Memahami dan mengimplementasikan operator, variabel array, pernyataan kondisional dan
perulangan dalam pemrograman java.

Modul Praktikum PBO 7

1.2 Pengenalan Java

1.2.1 Sejarah singkat Java

Java dibuat dan diperkenalkan pertama kali oleh sebuah tim Sun Microsystem yang
dipimpin oleh Patrick Naughton dan James Gosling pada tahun 1991 dengan code nama
Oak. Tahun 1995 Sun mengubah nama Oak tersebut menjadi Java.

Teknologi java diadopsi oleh Netscape tahun 1996. JDK 1.1 diluncurkan tahun 1996,
kemudian JDK 1.2, berikutnya J2EE (Java 2 Enterprise Edition) yang berbasis J2SE yaitu
servlet, EJB dan JSP.dan yang terakhir adalah J2ME (Java 2 Micro Edition) yang diadopsi
oleh Nokia, Siemens, Motorolla, Samsung, dan SonyEricsson.

Ide pertama kali kenapa java dibuat adalah karena adanya motivasi untuk membuat sebuah
bahasa pemrograman yang bersifat portable dan platform independent (tidak tergantung
mesin dan sistem operasi) yang dapat digunakan untuk membuat piranti lunak yang dapat
ditanamkan (embedded) pada berbagai macam peralatan elektronik consumer biasa, seperti
microwave, remote control, telepon, card reader dan sebagainya.

1.2.2 Karakteristik Java

Karakteristik Java adalah sebagai berikut :
1. Berorientasi Objek, Java telah menerapkan konsep pemrograman berorientasi objek yang
modern dalam implementasinya.
2. Robust, java mendorong pemrograman yang bebas dari kesalahan dengan bersifat strongly
typed dan memiliki run-time checking
3. Portable, Program Java dapat dieksekusi di platform manapun selama tersedia Java Virtual
Machine untuk platform tersebut.
4. Multithreading, Java mendukung penggunaan multithreading yang telah terintregasi langsung
dalam bahasa java
5. Dinamis, Program java dapat melakukan suatu tindakan yang ditentukan pada saat eksekusi
program dan bukan pada saat kompilasi
6. Sederhana, Java menggunakan bahasa yang sederhana dan mudah dipelajari.
7. Terdistribusi, java didesain untuk berjalan pada lingkungan yang terdistribusi seperti halnya
internet.
8. Aman, Java memiliki arsitektur yang kokoh dan pemrograman yang aman.

1.2.3 Garbage Collection

Teknik yang digunakan Java untuk penanganan objek yang telah tidak diperlukan untuk dimusnahkan
(dikembalikan ke pool memori) disebut garbage collection. Java interpreter melakukan pemeriksaan
untuk mengetahui apakah objek di memori masih diacu oleh program. Java interpreter akan
mengetahui objek yang telah tidak dipakai oleh program. Ketika Java interpreter mengetahui objek itu,
maka Java interpreter akan memusnahkan secara aman.

Modul Praktikum PBO 8

Java garbage collector berjalan sebagai thread berprioritas rendah dan melakukan kerja saat tidak ada
kerja lain di program. Umumnya, Java garbage collector bekerja saat idle pemakai menunggu masukan
dari keyboard atau mouse. Garbage collector akan bekerja dengan prioritas tinggi saat interpreter
kekurangan memori. Hal ini jarang terjadi karena thread berprioritas rendah telah melakukan tugas
dengan baik secara background.

1.3 Instalasi Netbeans

Sebelum install Netbeans kita perlu install JDK terlebih dahulu.

1.3.1 Instalasi JDK (Java Development Kit)

Pada Windows, file instalasi berupa self-installing file, yaitu file exe yang bila dijalankan akan
mengekstrak dirinya untuk dikopikan ke direktori. Prosedur installasi akan menawarkan default untuk
direktori instalasi seperti jdk1.4, jdk1.5, jdk 1.6 atau yang terbaru jdk1.7. Kita sebaiknya tidak
mengubahnya karena kita dapat mengkoleksi beragam versi JDK, secara default.

Gambar 1-1Tampilan awal instalasi Java (JDK 1.7) di windows

Gambar 1-2 Pemilihan directory tempat penginstalan Java

Modul Praktikum PBO 9

Selanjutnya klik “Next” dan tinggal mengikuti semua alur instalasi sampai proses instalasi selesai.

1.3.2 Netbeans
Setelah instalasi JDK selesai, tinggal double installer Netbeans terbaru yang dapat diunduh di
http://www.netbeans.org.

Di dalam netbeans, semua perancangan dan pemrograman dilakukan di dalam kerangka sebuah
proyek.Proyek netbeans merupakan sekumpulan file yang dikelompokkan di dalam suatu kesatuan.

• Membuat proyek
Sebelum membuat program java dengan menggunakan netbeans, langkah pertama adalah membuat
proyek terlebih dahulu.

1 Jalankan menu File | Project (Ctrl+Shift+N) untuk membuka suatu dialog New Project.

Gambar 1-3 Tampilan Dialog New Project

2 Dalam dialog, pilih Categories : General danProjects : Java Application. Lalu klik tombol next.
3 Pilih dahulu lokasi project dengan menekan tombol browse. Akan tampil direktori dan kita dapat
memilih di direktori mana project disimpan. Setelah memilih, klik open.
4 Kembali ke dialog new project, isikan project name. Misalnya disini project name : HelloWord.
Perhatikan bahwa project folder secara otomatis akan diset sesuai dengan nama project.
5 Centang pada Set as Main Project dan pada Create Main Class. Terakhir klik tombol finish.
Di dalam netbeans akan dibuka secara otomatis file utama java bernama main.java yang berada pada
package helloword.

• Memulai membuat program sederhana di Java

Setelah membuat proyek di Netbeans , selanjutnya membuat program sederhana . Di bawah ini
merupakan contoh program yang akan menampilkan “Hello Word”.
public class Main {
public static void main(String[] args) {
System.out.println("Hello Word");
}

Modul Praktikum PBO 10

}
• Mengcompile dan menjalankan program java di Netbeans
Untuk mengcompile dan menjalankan klik Run→ Run Main Project , seperti gambar dibawah ini:

Gambar 1-4 Tampilan Run Main Project

Jika programnya sukses maka akan tampil tulisan hello word seperti di bawah ini :

Gambar 1-5 Tampilan hasil compile

1.4 Tipe Data, Variabel, dan Konstanta

1.4.1 Tipe data dan Variabel

Hampir bisa dipastikan bahwa sebuah program selalu membutuhkan lokasi memori untuk menyimpan
data yang sedang diproses. Kita tidak pernah tahu di lokasi memori mana computer akan meletakkan
datadari program kita. Kenyataan ini menimbulkan kesulitan bagi kita untuk mengambil data tersebut
pada saat dibutuhkan. Maka dikembangkan konsep variable. Setiap variable memiliki jenis alokasi
memori tersendiri, misalnya bilangan bulat, bilangan pecahan, karakter, dan sebagainya. Ini sering
disebut dengan tipe data.

Secara umum ada tiga bentuk data:

ABCD
EFGH
IJKL TRUE | FALSE
Karakter
Numerik Logika

1. Numerik, data yang berbentuk angka atau bilangan. Data numerik bisa dibagi atas dua kategori :
• Bilangan bulat (integer), yaitu bilangan yang tidak mengandung angka pecahan.
• Bilangan pecahan (float), yaitu bilangan yang mengandung angka pecahan.

Modul Praktikum PBO 11

 2. Karakter, data yang berbentuk karakter atau deretan karakter. Karakter bisa dibagi menjadi dua
kategori :
• Karakter tunggal.
• Deretan karakter.
3. Logika, yaitu tipe data dengan nilai benar (true) atau salah (false).
Pada dasarnya ada dua macam tipe variable data dalam bahasa Java, yakni
• tipe primitif, meliputi : tipe boolean, tipe numerik (yang meliputi : byte, short, int, long,
char, float, double) dan tipe karakter (char).
• tipe referensi,meliputi tipe variabel data : tipe kelas, tipe array, tipe interface.Ada pula tipe
variabel data khusus yang disebut null types, namun variable dalam Java tidak akan memiliki
tipe null ini.
Bentuk umum pendeklarasian variable:
tipeData namaVariable1 [= nilaiAwal];
tipeData namaVariable1 [= nilaiAwal], [namaVariable2 = [nilaiAwal], …];

Contoh untuk mendeklarasikan sebuah variable :

int dataint;
char chardata;
float x = 12,67;

Penamaan sebuah variabel dalam Java harus memenuhi aturan sebagai berikut :
1. Harus terdiri atas sederetan karakter Unicode yang diawali oleh karakter huruf atau garis
bawah. Unicode merupakan system penkodean karakter yang dapat dibaca oleh berbagai
bahasa manusia.
2. Tidak boleh berupa keyword (kata yang dicadangkan), null, atau literal true/false.
3. Harus unik dalam suatu scope.

Dalam gaya pemrograman dengan java, biasanya mengikuti format nama variable, yaitu:
1. Diawali dengan huruf kecil
2. Jika nama variable lebih dari satu kata, kata ke-2, ke-3 dan seterusnya diawali dengan huruf
capital dan ditulis menyatu.

1.4.2 Konstanta
Variabel dalam Java bisa dijadikan konstanta, sehingga nilainya tidak akan dapat diubah-ubah dengan
mendeklarasikannya sebagai variable final seperti contoh :

final int x = 2;

1.5 Variabel Array

Untuk memudahkan pemahaman mengenai variable array, digunakan ilustrasi kotak yang
merepresentasikan setiap elemen variable array. Sebuah variable array bisa digambarkan berupa kotak
sebagai berikut :
[---------------------- Variable Array -------------------]

Data ---------> Data 1 Data 2 Data 3 …. Data N

Index ---------> 0 1 2 … N-1

Modul Praktikum PBO 12

Index adalah sebuah angka yang menyatakan urutan sebuah elemen pada suatu variable array. Karena
seluruh kotak memiliki nama yang sama, maka untuk membedakannya diperlukan suatu cara yaitu
dengan memberi nomor urut. Ibarat deretan rumah pada sebuah jalan, untuk membedakan antara
rumah yang satu dengan rumah yang lain maka setiap rumah diberi nomor unik yang berbeda antara
rumah satu dangan yang lainnya.

1.5.1 Deklarasi variabel array

Bentuk umum pendeklarasian variable array di Java adalah :
tipeData[] namaVariable = new tipeData [jumlahElemen];
atau
tipeData namaVariable[] = new tipeData [jumlahElemen] ;

TipeData bisa berupa salah satu dari berbagai tipe data seperti int, long, double maupun nama kelas;
baik kelas standar Java atau kelas buatan kita sendiri. Materi kelas tidak akan dibahas dalam modul ini.
Cara pendeklarasian variable array :
1. Mendeklarasikan variable array tanpa menyebutkan berapa jumlah elemen yang diperlukan
int[] variableArray1;
Untuk deklarasi variable array dengan cara ini, kita harus menuliskan di salah satu baris program
instruksi untuk memesan jumlah elemen untuk variable tersebut. Sebelum terjadi pemesanana
jumlah elemen, kita tidak bisa menggunakan variable array ini untuk menyimpan data.
variableArray1 = new int[5];

2. Mendeklarasikan variable array dengan menyebutkan jumlah elemen yang diperlukan

int[] variableArray2 = new int[5];
Pada saat mendeklarasikan variable array ini, maka kita langsung memesan 5 elemen array
yang akan kita gunakan selanjutnya.

3. Mendeklarasikan variable array secara otomatis

int[] varibleArray3 = {5, 3, 23, 99, 22};
atau
int[] variableArray3 = new int[]{1,23,45,4,3};
variable array ini memiliki 5 elemen, dan tiap elemen sudah terisi data. Berbeda dengan cara
pendeklarasian yang pertama dan yang kedua.

1.5.2 Mengakses variable array

Mengakses suatu variable berarti mengisi data ke variable tersebut atau mengambil data dari variable
tersebut. Mengakses variable array berarti kita mengakses elemen dari variable array tersebut.
int tampung = var1[2];
Untuk mengisi nilai ke variabel array, sebutkan nomor indeks elemen yang akan diisi dengan nilai.
var1[5]=65
Untuk mengambil nilai dari variable array, sebutkan nomor indeks elemen yang akan kita ambil isinya.
var1[0] = var1[5] + var1[9];

Instruksi di atas akan menjumlahkan isi variable var1 elemen ke-6 dan ke-10 lalu menyimpan hasilnya
ke elemen pertama.

Modul Praktikum PBO 13

1.5.3 Array 2 Dimensi
Bentuk umum pendeklarasian variable array dua dimensi di Java adalah :
tipeData[][] namaVariable = new tipeData[jumlahBaris][jumlahKolom];
atau
tipeData namaVariable[][] = new tipeData[jumlahBaris][jumlahKolom];

Cara pendeklarasian variable array dua dimensi sama dengan cara pendeklarasian variable array satu
dimensi.
Mengakses variable array dua dimensi, mengisi variable array dua dimensi, mengambil variable array
dua dimensi juga sama dengan cara yang berlaku pada variable array satu dimensi, yaitu dengan
menyebutkan nomor indeks dari elemen. Perbedaanya hanya pada dua dimensi harus menyebutkan
indeks baris dan indeks kolom.
Menghitung jumlah elemen pada array dua dimensi
long[][] gede = new long[5][5]; /*deklarasi variable array dua dimensi*/
gede.length; // akan melaporkan jumlah baris, sedangkan
gede[i].length; // akan melaporkan jumlah kolom pada baris
ke-i
Contoh matrik 2 dimensi :
public class Matrik2
{
public static void main(String[] args)
{
double m[][];
m = new double[4][4];
m[0][0] = 1;
m[1][1] = 1;
m[2][2] = 1;
m[3][3] = 1;
System.out.println(m[0][0]+" "+m[0][1]+" "+m[0][2]+" "+m[0][3]);
System.out.println(m[1][0]+" "+m[1][1]+" "+m[1][2]+" "+m[1][3]);
System.out.println(m[2][0]+" "+m[2][1]+" "+m[2][2]+" "+m[2][3]);
System.out.println(m[3][0]+" "+m[3][1]+" "+m[3][2]+" "+m[3][3]);
}
}

1.6 Operator,Pernyataan Kondisional, dan Perulangan

1.6.1 Operator
Operator-operator yang digunakan pada java ada beberapa jenis diantaranya yaitu:
• Operator Aritmatika. • Operator Shift dan Bitwise
• Operator Relasional • Operator Assignment
• Operator Kondisional
Operator Aritmatika
Operator ini digunakan pada operasi-operasi aritmatika seperti penjumlahan, pengurangan, pembagian
dll. Operator-operator yang digunakan yaitu :
Operator Contoh Keterangan
+ a+b Menambahkan a dengan b
- a–b Mengurangkan a dengan b
* a*b Mengalikan a dengan b

Modul Praktikum PBO 14

 / a / b Membagi a dengan b
% a % b Menghasilkan sisa pembagian antara a dengan b
++ a ++ Menaikkan nilai a sebesar 1
-- a -- Menurunkan nilai a sebesar 1
- -a Negasi dari a.
Operator Relasional
Untuk membandingkan 2 nilai (variabel) atau lebih digunakan operator Relasional, dimana operator ini
akan mengembalikan atau menghasilkan nilai True atau False. Jenis-jenisnya yaitu:
Operator Contoh Keterangan
> a>b True jika a lebih besar dari b
< a<b True jika a lebih kecil dari b
>= a >= b True jika a lebih besar atau sama dengan b
<= a <= b True jika a lebih kecil atau sama dengan b
== a == b True jika a sama dengan b
!= a != b True jika a tidak sama dengan b
Operator Kondisional
Operator ini menghasilkan nilai yang sama dengan operator relasional, hanya saja penggunaanya lebih
pada operasi-operasi boolean. Jenisnya yaitu:
Operator Contoh Keterangan
&& a && b True jika a dan b, keduanya bernilai True
|| a || b True jika a atau b bernilai True
! !a True jika a bernilai False
Operator Shift dan Bitwise
Dua perator ini digunakan untuk memanipulasi nilai dari bitnya,sehingga diperoleh nilai yang lain.
Operator Shift
Operator Penggunaan Deskripsi
>> a >> b Menggeser bit a ke kanan sejauh b
<< a << b Menggeser bit a ke kiri sejauh b
>>> a >>> b Menggeser bit a ke kanan sejauh b
Operator Bitwise
Operator Penggunaan Deskripsi
& a&b Bitwise AND
| a|b Bitwise OR
^ a^b Bitwise XOR
~ ~a Bitwise Complement
Operator Assignment
Operator assignment dalam Java digunakan untuk memberikan sebuah nilai ke sebuah variable.
Operator assignment hanya berupa ‘=’, namun selain itu dalam Java dikenal beberapa shortcut
assignment operator yang penting, yang digambarkan dalam table berikut :
Operator Contoh Ekivalen dengan
+= a += b a=a+b

Modul Praktikum PBO 15

-= a -= b a=a–b
*= a *= b a=a*b
/= a /= b a=a/b
%= a %= b a=a%b
&= a&= b a = a&b
|= a |= b a=a|b
^= a ^= b a=a^b
<<= a<<= b a = a<<b
>>= a>>= b a = a>>b
>>>= a>>>= b a = a>>>b

1.6.2 Pernyataan kondisional

Statement if
Statement if memungkinkan sebuah program untuk dapat memilih beberapa operasi untuk dieksekusi,
berdasarkan beberapa pilihan. Dalam bentuknya yang paling sederhana, bentuk if mengandung sebuah
pernyataan tunggal yang dieksekusi jika ekspresi bersyarat adalah benar. Bentuk if yang paling
sederhana yaitu :
if ( ekspresi_kondisional ) {
statement 1;
statement 2;
……
}
Statement if-else
Untuk melakukan beberapa operasi yang berbeda jika salah satu ekspresi_kondisional bernilai salah,
maka digunakan statement else. Bentuk if-else memungkinkan kode Java memungkinkan dua alternatif
operasi pemrosesan : satu jika statement bersyarat adalah benar dan satu jika salah.
• Bentuk statement if – else dengan 2 pilihan operasi pemrosesan
if ( ekspresi_kondisional ){
statement 1;
statement 2;
……
}else{
statement 1;
statement 2;
……
}
• Bentuk statement if– else dengan beberapa pilihan operasi pemrosesan
if ( ekspresi_kondisional_A ){
statement 1;
statement 2;
……
}else if( ekspresi_kondisional_B ){
statement 1;
statement 2;
……
}else{
statement 1;
statement 2;
……

Modul Praktikum PBO 16

}
Contoh :
class IfElse {
public static void main(String args[]) {
int month = 4;
String season;
if (month == 12 || month == 1 || month == 2) {
season = "Dingin";
} else if (month == 3 || month == 4 || month == 5) {
season = "Semi";
} else if (month == 6 || month == 7 || month == 8) {
season = "Panas";
} else if (month == 9 || month == 10 || month == 11) {
season = "Gugur";
} else {
season = "";
}
System.out.println("Bulan April masuk musim " + season + ".");
}
}

Statement switch
Bentuk umum pernyataan switch adalah sebagai berikut :
switch ( expression ) {
case value_l :
statement 1;
statement 2;
. . .
break;
case value_2 :
statement 1;
statement 2;
. . .
break;
[default:]
statement 1;
statement 2;
. . .
break;}
}
Kata-kunci case menandai posisi kode dimana eksekusi diarahkan. Sebuah konstanta integer atau konstanta
karakter mengikutinya, atau ekspresi yang mengevaluasi konstanta integer atau konstanta karakter. Sedangkan
kata default ekivalensi dengan kata else pada statement if.

Ekspresi bersyarat
Kita menggunakan sebuah ekspresi bersyarat untuk menggantikan sebuah bentuk if-else. Sintaks adalah sebagai
berikut :
exp1 ? exp2 : exp3

Dalam hal ini, jika exp1 adalah benar, exp2 dieksekusi. Jika exp2 adalah salah, exp3 dieksekusi.
Contoh :
int a = 4;
int b = 5;

Modul Praktikum PBO 17

int nilai = 3 > 2 ? a : b;

Outputnya :
nilai = 4
1.6.3 Perulangan
While
Syntax :
while( expression ){
statement 1;
statement 2;
.......
}

Selama ekspresi benar while akan dieksekusi.

Do
Hasil dari while akan dikembalikan kepada do. Syntax do-while loop :
do {
statement 1;
statement 2;
.......
} while(expression)
while ( expression );
for
Syntax :
for ( initialization ; expression ; step ) {
statement 1;
statement 2;
...
}

Pada java terdapat 2 statement yang biasanya digunakan pada setiap bentuk iterasi diatas. Statement
tersebut yaitu :
• break, dapat menghentikan perulangan walaupun kondisi untuk berhenti belum terpenuhi.
• continue, dengan statement ini kita bisa melewatkan operasi yang dilakukan dalam iterasi sesuai
dengan kondisi tertentu.

Contoh : Menampilkan angka 1-10

public class angka {
public static void main(String[] args) {
int i;
for(i=1;i<=10;i++){
System.out.println(Integer.toString(i));
}
i=1;
while(i<=10) {
System.out.println(Integer.toString(i));
i++;
}
i=1;

Modul Praktikum PBO 18

 do {
System.out.println(Integer.toString(i));
i++;
}
while(i<=10)
}
}

Output:
PBOkerenPBOkerenPBOkerenProgrammingLab

Fill in the blank

public class pbo {
public static void main (String[] args) {
int x = 0;
while (x< ________ ) {
System.out.__________(“PBO”);
System.out.__________(“keren”);
x = ________;
}
if (x == ______){
System.out.print(“ProgrammingLab”);
}
}
}

Modul Praktikum PBO 19

 Modul 2 : Konsep Dasar Pemrograman Berorientasi Objek

2.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat:
1. Mengerti konsep dasar object oriented programming
2. Dapat membandingkan antara pemrograman prosedural dengan pemrograman berorientasi object.
3. Memahami Kelas, Object, Method dan Constructor, serta mengimplementasikannya dalam suatu
program java

2.2 Pendahuluan
Sebelum membahas tentang kelas terlebih dahulu kita perlu mengetahui konsep pemrograman
berorientasi objek. Suatu sistem yang dibangun dengan metode berorientasi objek adalah sebuah
sistem yang komponennya di-enkapsulasi menjadi kelompok data dan fungsi, yang dapat mewarisi
atribut dan sifat dari komponen lainnya dan komponen-komponen tersebut saling berinteraksi satu
sama lain.

Beberapa karakteristik utama dalam pemrograman berorientasi objek yaitu :

2.2.1 Abstraksi
Abstraksi pada dasarnya adalah menemukan hal-hal yang esensial pada suatu objek dan mengabaikan
hal-hal yang sifatnya insidental. Kita menentukan apa ciri-ciri (atribut) yang dimiliki oleh objek tersebut
serta apa saja yang bisa dilakukan (metode/perilaku) oleh objek tersebut.
Contohnya adalah abstraksi pada manusia.
Ciri-ciri (atribut) : punya tangan, berat, tinggi, dll. (kata benda, atau kata sifat)
Fungsi (perilaku): makan, minum, berjalan, dll. (kata kerja)
2.2.2 Enkapsulasi
Pengkapsulan adalah proses pemaketan data objek bersama method-methodnya. Manfaat utama
pengkapsulan adalah penyembunyian rincian-rincian implementasi dari pemakai/objek lain yang tidak
berhak. Enkapsulasi memprotek suatu proses dari kemungkinan interferensi atau penyalahgunaan dari
luar sistem.
Fungsi dari enkapsulasi adalah:
a. Penyembunyian data
Penyembunyian data (data hiding) mengacu perlindungan data internal objek. Objek tersebut
disusun dari antarmuka public method dan private data. Manfaat utama adalah bagian internal
dapat berubah tanpa mempengaruhi bagian-bagian program yang lain.
b. Modularitas
Modularitas (modularity) berarti objek dapat dikelola secara independen. Karena kode sumber
bagian internal objek dikelola secara terpisah dari antarmuka, maka kita bebas melakukan
modifikasi yang tidak menyebabkan masalah pada bagian-bagian lain. Manfaat ini mempermudah
mendistribusikan objek-objek di sistem.
Contoh ilustrasi pada mobil.

Modul Praktikum PBO 20

 Mobil memiliki sistem transmisi dan sistem ini
menyembunyikan proses yang terjadi di dalamnya
tentang bagaimana cara ia bekerja, mulai dari
bagaimana cara ia mengatur percepatan dan apa yang
dilakukan terhadap mesin untuk mendapat percepatan
tersebut.

Kita sebagai pengguna hanya cukup memindah-

mindahkan tongkat transmisi (kopling) untuk
mendapatkan percepatan yang diinginkan. Tongkat
transmisi adalah satu-satunya interface yang digunakan
dalam mengatur sistem transmisi mobil tersebut. Kita tidak
dapat menggunakan pedal rem untuk mengakses sistem
transmisi tersebut dan sebaliknya dengan mengubah-ubah
sistem transmisi kita tidak akan bisa menghidupkan radio
mobil atau membuka pintu mobil. Konsep yang sama
dapat pula kita terapkan dalam pemrograman orientasi
objek.

2.2.3 Pewarisan (Inheritance)

Pewarisan adalah proses penciptaan kelas baru (yang disebut subclass atau kelas turunan) dengan
mewarisi karakteristik dari kelas yang telah ada (superclass atau kelas induk), ditambah karakteristik
unik kelas baru itu. Karakteristik unik tersebut bisa merupakan perluasan atau spesialisasi dari
superclass.Kelas turunan akan mewarisi anggota-anggota suatu kelas yang berupa data (atribut) dan
fungsi (operasi) dan pada kelas turunan memungkinkan menambahkan data serta fungsi yang baru.
Secara praktis berarti bahwa jika superclass telah mendefinisikan perilaku yang kita perlukan, maka kita
tidak perlu mendefinisi ulang perilaku itu, kita cukup membuat kelas yang merupakan subclass dari
superclass yang dimaksud.
2.2.4 Reuseability
Reuseability adalah kemampuan untuk menggunakan kembali kelas yang sudah
ada. Karakteristik ini dimiliki oleh OOP, sehingga kita tidak perlu membuat ulang
definisi perilaku jika perilaku tersebut sudah ada di suatu kelas lain.

2.2.5 Polymorphisms
Polymorphism berasal dari bahasa Yunani yang berarti banyak bentuk. Konsep ini memungkinkan
digunakannya antarmuka (interface) yang sama untuk memerintah suatu objek agar dapat melakukan
aksi atau tindakan yang mungkin secara prinsip sama tapi secara proses berbeda. Seringkali
Polymorphism disebut dengan “satu interface banyak aksi”. Mekanisme Polymorphism dapat dilakukan
dengan dengan beberapa cara, seperti overloading method, overloading constructor, maupun
overriding method. Semua akan dibahas pada bab selanjutnya.

Modul Praktikum PBO 21

 Contoh ilustrasi pada mobil. Mobil yang ada di
pasaran terdiri atas berbagai tipe dan merek,
tetapi semuanya memilki interface kemudi yang
hampir sama seperti setir, tongkat transmisi,
pedal gas, dll. Jika kita dapat mengemudikan
satu jenis mobil saja dari satu merek tertentu,
maka boleh dikatakan kita dapat
mengemudikan hampir semua jenis mobil yang
ada karena semua mobil tersebut menggunakan
interface yang sama. Misal, ketika kita menekan
pedal gas pada mobil A, kita telah berhasil
menggerakkan mobil A tersebut dengan
percepatan yang tinggi. Sebaliknya, ketika kita
menggunakan mobil B dan sama-sama
menekan pedal gas, mobil B ini bergerak agak
lambat. Jadi, dapat disimpulkan dengan sama-
sama kita menekan pedal gas pada dua mobil ini
akan didapatkan hasil yang berbeda pada
keduanya.

2.2.6 Message (Komunikasi antar objek)

Objek yang bertindak sendirian jarang berguna, kebanyakan objek memerlukan objek-objek lain untuk
melakukan banyak hal. Oleh karena itu, objek-objek tersebut saling berkomunikasi dan berinteraksi
lewat message. Ketika berkomunikasi, suatu objek mengirim pesan (dapat berupa pemanggilan
method) untuk memberitahu agar objek lain melakukan sesuatu yang diharapkan. Seringkali pengiriman
message juga disertai informasi untuk memperjelas apa yang dikehendaki. Informasi yang dilewatkan
beserta message adalah parameter message.

2.3 Kelas
Kelas adalah cetak biru (rancangan) dari objek. Ini berarti kita bisa membuat banyak objek dari satu
macam kelas. Kelas mendefiniskan sebuah tipe dari objek. Di dalam kelas kita dapat mendeklarasikan
variabel dan menciptakan object(instansiasi). Sebuah kelas mempunyai anggota(member) yang terdiri
atas atribut dan method. Atribut adalah semua field identitas yang kita berikan pada suatu kelas, misal
kelas manusia memiliki field atribut berupa nama, maupun umur. Method dapat kita artikan sebagai
semua fungsi ataupun prosedur yang merupakan perilaku (behaviour) dari suatu kelas. Dikatakan
fungsi bila method tersebut melakukan suatu proses dan mengembalikan suatu nilai (return value), dan
dikatakan prosedur bila method tersebut hanya melakukan suatu proses dan tidak mengembalikan
nilai (void).
Contoh pendeklarasian kelas:
class <classname>
{
//declaration of data member
//declaration of methods
}
Kata class merupakan keyword pada Java yang digunakan untuk mendeklarasikan kelas dan
<classname> digunakan untuk memberikan nama kelas. Sebagai contoh, dibawah ini terdapat
pendeklarasian kelas Mahasiswa yang mempunyai field nama, nim dan method getNamaMahasiswa().

Modul Praktikum PBO 22

class Mahasiswa
{
String nama; //data anggota
int nim; //data anggota
void getNamaMahasiswa() {}; //method
}

Setelah mengetahui apa itu kelas , selanjutnya kita perlu mengetahui Object dan Java Modifier
2.3.1 Object
Object (objek) secara lugas dapat diartkan sebagai insatansiasi atau hasil ciptaan dari suatu kelas yang
telah dibuat sebelumnya. Dalam pengembangan program orientasi objek lebih lanjut, sebuah objek
dapat dimungkinkan terdiri atas objek-objek lain. Seperti halnya objek mobil terdiri atas mesin, ban,
kerangka mobil, pintu, karoseri dan lain-lain. Atau, bisa jadi sebuah objek merupakan turunan dari objek
lain sehingga mewarisi sifat-sifat induknya. Misal motor dan mobil merupakan kendaraan bermotor,
sehingga motor dan mobil mempunyai sifat-sifat yang dimiliki oleh kelas kendaraan bermotor dengan
spesifikasi sifat-sifat tambahan sendiri.

Contoh object yang lain : Komputer, TV, mahasiswa, ponsel, lbuku, dan lainnya.
Contoh pembuatan Objek dalam java:
Manusia objMns1 = new Manusia();//membuat objek manusia

2.3.2 Java Modifier

Modifier memberi dampak tertentu pada kelas, interface, method, dan variabel. Java modifier terbagi
menjadi kelompok berikut:
1. Access modifier berlaku untuk kelas, method dan variabel, meliputi modifier public, protected,
private, dan default (tak ada modifier).
2. Final modifier berlaku kelas, method dan variabel, meliputi modifier final.
3. Static modifier berlaku untuk variabel dan method, meliputi modifier static.
4. Abstract modifier berlaku untuk kelas dan method, meliputi modifierabstract.
5. Syncronized modifier berlaku untuk method, meliputi modifier syncronized .
6. Native modifier berlaku untuk method, meliputi modifier native.
7. Storage modifier berlaku untuk variabel, meliputi transient dan volatile.

Berikut ini modifier-modifier yang terdapat pada java :

Modifier Kelas dan Interface Method dan Variabel
Default (tak ada Tampak di Paketnya Diwarisi oleh subclassnya di paket yang sama dengan
modifier ) kelasnya. Dapat diakses oleh method-method di kelas-
Friendly kelas yang sepaket.
Public Tampak di manapun Diwarisi oleh semua subclassnya. Dapat diakses
dimanapun.
protected Tidak dapat Diwarisi oleh semua subclassnya. Dapat diakses oleh
diterapkan method-method di kelas-kelas yang sepaket.
Private Tidak dapat Tidak diwarisi oleh subclassnya
diterapkan Tidak dapat diakses oleh kelas lain.

Modul Praktikum PBO 23

Permitted Modifier:
Modifier Kelas Interface Method Variabel
Abstract Kelas dapat Optional untuk Tidak ada badan method Tidak dapat
berisi method diberikan di yang didefinisikan. Method diterapkan.
abstract. Kelas interface karena memerlukan kelas kongkret
tidak dapat interface secara yang merupakan subclass
diinstantiasi inheren adalah yang akan
Tidak abstract. mengimplementasikan
mempunyai method abstract
constructor
Final Kelas menjadi Tidak dapat Method tidak dapat Berperilaku sebagai
tidak dapat diterapkan. ditimpa oleh method di konstanta
digunakan subclass-subclassnya
untuk
menurunkan
kelas yang baru.
Static Tidak dapat Tidak dapat Mendefinisikan method Mendefinisikan
diterapkan. diterapkan. (milik) kelas. Dengan variable milik kelas.
demikian tidak Tidak memerlukan
memerlukan instant object instant object untuk
untuk menjalankanya. mengacunya. Variabel
Method ini tidak dapat ini dapat digunakan
menjalankan method yang bersama oleh semua
bukan static serta tidak instant objek.
dapat mengacu variable
yang bukan static.
synchron Tidak dapat Tidak dapat Eksekusi dari method Tidak dapat
ized diterapkan. diterapkan. adalah secara mutual diterapkan pada
exclusive diantara semua deklarasi. Diterapkan
thread. Hanya satu thread pada instruksi untuk
pada satu saat yang dapat menjaga hanya satu
menjalankan method thread yang mengacu
variable pada satu
saat.
native Tidak dapat Tidak dapat Tidak ada badan method Tidak dapat
diterapkan. diterapkan. yang diperlukan karena diterapkan.
implementasi dilakukan
dengan bahas lain.
transient Tidak dapat Tidak dapat Tidak dapat diterapkan. Variable tidak akan
diterapkan. diterapkan. diserialisasi
Volatile Tidak dapat Tidak dapat Tidak dapat diterapkan. Variabel diubah secara
diterapkan. diterapkan. asinkron. Kompilator
tidak pernah
melakukan optimasi
atasnya.

Modul Praktikum PBO 24

Deklarasi modifier dalam java :
[Modifier] class/interface [nama class/interface] {} /*deklarasi modifier
di class/interface*/

[Modifier][TypeData][nama Atribut]; //deklarasi modifier di atribut

[Modifier]{[TypeData]}[nama method](parameter_1,parameter_2,parameter_n) {}
//deklarasi modifier di method

Contoh :
public class Manusia {} //contoh modifier di class
private int tinggi; //contoh modifier di atribut
public int getTinggi(){} //contoh modifier di method

Contoh kelas yang mempunyai akses modifier ini ditunjukan pada diagram kelas Manusia berikut ini.
Manusia
- nama : String
- umur : int
+ setNama : void
+ getNama : String
+ setUmur : void
+ getUmur : int

Keterangan : tanda - artinya memiliki access modifier private

+ artinya memiliki access modifier public
# artinya memiliki access modifier protected
Contoh implementasi di dalam program:
public class Manusia {

//definisi atribut
private String nama;
private int umur;

//definisi method
public void setNama(String a){
nama=a;
}
public String getNama(){
return nama;
}
public void setUmur(int a){
umur=a;
}

public int getUmur(){

return umur;
}
}

Kesepakatan umum penamaan dalam suatu Kelas :

Modul Praktikum PBO 25

 1. Nama Kelas – gunakan kata benda dan huruf pertama dari tiap kata ditulis dengan huruf besar
dan memiliki access modifier public : Manusia
2. Pada umumnya, atribut diberi access modifier private, dan method diberi access modifier
public. Hal ini diterapkan untuk mendukung konsep OO yaitu enkapsulasi mengenai data
hiding. Jadi, kita tidak langsung menembak data/atribut pada kelas tersebut, tetapi kita
memberikan suatu antarmuka method yang akan mengakses data/atribut yang disembunyikan
tersebut.
3. Nama atribut - gunakan kata benda, dan diawali dengan huruf kecil : nama, umur
4. Nama Method – gunakan kata kerja; kecuali huruf yang pertama, huruf awal tiap kata ditulis
kapital : getNama(), getUmur()
5. Untuk method yang akan memberikan atau mengubah nilai dari suatu atribut, nama method
kita tambahi dengan kata kunci ”set”. : setUmur(int a), setNama(String a)
6. Untuk method yang akan mengambil nilai dari atribut, nama method kita tambahi dengan kata
kunci ”get” : getUmur(), getNama()
7. Konstanta. Semuanya ditulis dengan huruf besar; pemisah antar kata menggunakan garis
bawah: MAX_VALUE, DECIMAL_DIGIT_NUMBER

2.4 Field
Field adalah sebuah atribut. Field bisa berupa sebuah variabel kelas, variabel objek, variabel method
objek atau parameter dari sebuah fungsi. Field merupakan anggota dari kelas yang digunakan untuk
menyimpan data. Terdapat dua field dalam kelas , dibawah ini adalah contoh kelas yang terdapat 2
jenis field tersebut.
public class Circle {
public static final double PI= 3.14159;
public static double radiansToDegrees(double rads) {
return rads * 180 / PI;
}
public double r;
public double area() {
return PI * r * r;
}
public double circumference() {
return 2 * PI * r;
}
}
• Class Field
Field yang dikaitkan dengan kelas di mana ia didefinisikan, bukan dengan sebuah instance dari kelas. Di
bawah ini menyatakan pendeklarasian kelas field pada class Circleadalah :

public static final double PI= 3.14159;

Static modifier diatas menyatakan bahwa field tersebut merupakan class field. Field ini berkaitan
dengan kelas itu sendiri tidak dengan instance dari kelas. Berdasarkan kelas Circle maka jika
terdapat method dari kelas Circle maka mengakses variabel PIdengan Circle.PI .
• Instance Field
Field apapun yang dideklarasikan tanpa menggunakan static modifier . Contoh instance field yang
terdapat pada kelas Circle adalah:

Modul Praktikum PBO 26

public double r;

Field ini merupakan field yang terkait dengan instance kelas bukan dengan kelas itu sendiri.
Berdasarkan kelas Circle , setiap objek Circle yang dibuat memiliki salinan sendiri field r.
Contohnya r menyatakan jari-jari lingkaran. Jadi setiap objek Circle dapat memiliki jari-jari sendiri dari
semua objek linkaran lainnya.

2.5 Method
Method dikenal juga sebagai suatu function dan procedure. Dalam OOP, method digunakan untuk
memodularisasi program melalui pemisahan tugas dalam suatu kelas. Pemanggilan method
menspesifikasikan nama method dan menyediakan informasi (parameter) yang diperlukan untuk
melaksanakan tugasnya.
Deklarasi method untuk yang mengembalikan nilai (fungsi)
[modifier] Type-data namaMethod(parameter1,parameter2,…parameterN)
{
Deklarasi-deklarasi dan proses ;
return nilai-kembalian
}

Type-data merupakan tipe data dari nilai yang dapat dikembalikan oleh method ini.
Deklarasi method untuk yang tidak mengembalikan nilai (prosedur)
[modifier] void namaMethod(parameter1,parameter2,…parameterN)
{
Deklarasi-deklarasi dan proses ;
}

Contoh implementasi method :

public int jumlahAngka(int x, int y)
{
int z=x+y;
return z;
}
Ada dua cara melewatkan argumen ke method, yaitu:
1. Melewatkan secara Nilai (Pass by Value)
Digunakan untuk argumen yang mempunyai tipe data primitif (byte, short, int, long, float,
double, char, dan boolean). Prosesnya adalah compiler hanya menyalin isi memori
(pengalokasian suatu variable), dan kemudian menyampaikan salinan tersebut kepada
method. Isi memory ini merupakan data “sesungguhnya” yang akan dioperasikan. Karena
hanya berupa salinan isi memory, maka perubahan yang terjadi pada variable akibat proses di
dalam method tidak akan berpengaruh pada nilai variable asalnya.
2. Melewatkan secara Referensi (Pass by Reference)
Digunakan pada array dan objek. Prosesnya isi memory pada variable array dan objek
merupakan penunjuk ke alamat memory yang mengandung data sesungguhnya yang akan
dioperasikan. Dengan kata lain, variable array atau objek menyimpan alamat memory bukan isi
memory. Akibatnya, setiap perubahan variable di dalam method akan mempengaruhi nilai
pada variable asalnya.

Contoh program

Modul Praktikum PBO 27

 class TestPass {
int i,j;
TestPass(int a,int b) {
i =a;
j = b;
}

//passed by value dengan parameter berupa tipe data primitif

void calculate(int m,int n) {
m = m*10;
n = n/2;
}
//passed by reference dengan berupa tipe data class
void calculate(TestPass e) {
e.i = e.i*10;
e.j = e.j/2;
}
}

class PassedByValue {
public static void main(String[] args) {
int x,y;
TestPass z;
z = new TestPass(50,100);
x = 10;
y = 20;

System.out.println("Nilai sebelum passed by value : ");

System.out.println("x = " + x);
System.out.println("y = " + y);

//passed by value
z.calculate(x,y);
System.out.println("Nilai sesudah passed by value : ");
System.out.println("x = " + x);
System.out.println("y = " + y);
System.out.println("Nilai sebelum passed by reference : ");
System.out.println("z.i = " + z.i);
System.out.println("z.j = " + z.j);

//passed by reference
z.calculate(z);

System.out.println("Nilai sesudah passed by reference : ");

System.out.println("z.i = " + z.i);
System.out.println("z.j = " + z.j);
}
}

Output dari program diatas

Nilai sebelum passed by value :
x = 10
y = 20
Nilai sesudah passed by value :
x = 10

Modul Praktikum PBO 28

 y = 20
Nilai sebelum passed by reference :
z.i = 50
z.j = 100
Nilai sesudah passed by reference :
z.i = 500
z.j = 50
Keterangan:
Pada saat pemanggilan method calculate() dengan metode pass by value, hanya nilai dari variable x dan
y saja yang dilewatkan ke variable m dan n , sehingga perubahan pada variable m dan n tidak akan
mengubah nilai dari variable x dan y. Sedangkan pada saat pemanggilan method calculate() dengan
metode pass by reference yang menerima parameter bertipe kelas Test. Pada waktu kita memanggil
method calculate() , nilai dari variable z yang berupa referensi ke obyek sesungguhnya dilewatkan ke
variable a , sehingga variable a menunjukkan ke obyek yang sama dengan yang ditunjuk oleh variable z
dan setiap perubahan pada objek tersebut dengan menggunakan variable a akan terlihat efeknya pada
variable z yang terdapat pada kode yang memanngil method tersebut.
2.6 keyword “this”
Dalam Java terdapat suatu besaran referensi khusus, disebut this, yang digunakan dalam method yang
dirujuk untuk objek yang sedang berlaku. Nilai this merujuk pada objek di mana method yang sedang
berjalan dipanggil.
Contoh implementasi program:
class Lagu {
private String pencipta;
private String judul;

public void IsiParam(String judul,String pencipta) {

this.judul = judul;
this.pencipta = pencipta;
}

public void cetakKeLayar() {

if(judul==null&& pencipta==null) return;
System.out.println("Judul : " + judul +", pencipta : " + pencipta);
}
}

class DemoLagu {
public static void main(String[] args) {
Lagu a = new Lagu();
a.IsiParam("God Will Make A Way","Don Moen ");
a.cetakKeLayar();
}
}

Keluaran dari program

Judul : God Will Make A Way, pencipta : Don Moen

keterangan
Perhatikan pada method IsiParam() di atas. Di sana kita mendeklarasikan nama variable yang
menjadi parameternya sama dengan nama variable yang merupakan property dari kelas Lagu
(judul dan pencipta). Dalam hal ini, kita perlu menggunakan keyword this(keyword ini merefer ke
Modul Praktikum PBO 29
objek itu sendiri) agar dapat mengakses property judul dan pencipta di dalam method IsiParam()
tersebut. Apa yang terjadi jika pada method IsiParam() keyword this dihilangkan ?
Keyword this juga dapat digunakan untuk memanggil suatu konstruktor dari konstruktor lainnya.
Contoh Program
public class Buku {
private String pengarang;
private String judul;
private Buku() {
this("Rumah Kita", "GoodBles"); // this ini digunakan untuk
memanggil konstruktor yang menerima dua parameter
}
private Buku(String judul,String pengarang)
{
this.judul = judul;
this.pengarang = pengarang;
}
private void cetakKeLayar()
{
System.out.println("Judul : " + judul + " Pengarang : " +
pengarang);
}
public static void main(String[] args)
{
Buku a,b ;
a = new Buku("Jurassic Park", "Michael Chricton");
b = new Buku();
a.cetakKeLayar();
b.cetakKeLayar();
}
}
Keluaran dari program diatas
Judul : Jurassic Park Pengarang : Michael Chricton
Judul : Rumah Kita Pengarang : GoodBles

Pada contoh program di atas, kita juga dapat mengambil pelajaran bahwa penggunaan modifier private
pada constructor mengakibatkan constructor tersebut hanya dapat dikenali dalam satu kelas saja,
sehingga pembuatan objek hanya dapat dilakukan dalam lokal kelas tersebut.
Catatan penting lainnya : bahwa method void main(String[] args) haruslah bersifat public static.
2.7 Constructor
Constructor adalah tipe khusus method yang digunakan untuk menginstansiasi atau menciptakan
sebuah objek. Nama constructor adalah sama dengan nama kelasnya. Selain itu, constructor tidak bisa
mengembalikan suatu nilai (not return value) bahkan void sekalipun. Defaultnya, bila kita tidak
membuat constructor secara eksplisit, maka Java akan menambahkan constructor default pada
program yang kita buat secara implisit. Constructor default ini tidak memiliki parameter masukan
sama sekali. Namun, bila kita telah mendefinisikan minimal satu buah constructor, maka Java tidak
akan menambah constructor default.
Constructor juga dimanfaatkan untuk membangun suatu objek dengan langsung mengeset atribut-
atribut yang disandang pada objek yang dibuat tersebut. Oleh karena itu, constructor jenis ini haruslah
memiliki parameter masukan yang akan digunakan untuk mengeset nilai atribut.

Modul Praktikum PBO 30

Access modifier yang dipakai pada constructor selayaknya adalah public karena constructor tersebut
akan diakses di luar kelasnya (walaupun kita juga bisa memberikan access modifier pada constructor
dengan private–artinya kita tidak bisa memanggil constructor tersebut di luar kelasnya). Cara
memanggil constructor adalah dengan menambahkan keyword new. Keyword new dalam deklarasi ini
artinya kita mengalokasikan pada memory sekian blok memory untuk menampung objek yang baru kita
buat.
Deklarasi constructor :
[modifier] namaclass(parameter1){
Body constructor;
}
[modifier] namaclass(parameter1,parameter2){
Body constructor;
}
[modifier] namaclass(parameter1,parameter2,…,parameterN){
Body constructor;
}

Contoh program sebelumnya dengan penambahan constructor eksplisit.

publicclass Manusia {
private String nama;
private int umur;
//definisi constructor
public Manusia(){ } //constructor pertama = default tanpa parameter
public Manusia(String a){ //constructor kedua
nama=a;
}
public Manusia(String a, int b){ //constructor ketiga
nama=a;
umur=b;
}
//definisi method
public void setNama(String a){
nama=a;
}
public String getNama(){
return nama;
}
public void setUmur(int a){
umur=a;
}
public int getUmur(){
return umur;
}
}
public class DemoManusia {
public static void main(String[] args) { //program utama
Manusia arrMns[] = new Manusia[3]; //buat array of object
Manusia objMns1 = new Manusia(); //constructor pertama
objMns1.setNama("Markonah");
objMns1.setUmur(76);

Modul Praktikum PBO 31

 Manusia objMns2 = new Manusia("Mat Conan"); //constructor kedua
Manusia objMns3 = new Manusia("Bajuri", 13); //constructor ketiga
arrMns[0] = objMns1;
arrMns[1] = objMns2;
arrMns[2] = objMns3;
for(int i=0; i<3; i++) {
System.out.println("Nama : "+arrMns[i].getNama());
System.out.println("Umur : "+arrMns[i].getUmur());
System.out.println();
}
}
}

Jika program di atas di-compile dan di running maka outputnya adalah sebagai berikut.
Nama : Markonah
Umur : 76
Nama : Mat Conan
Umur : 0
Nama : Bajuri
Umur : 13
Coba Anda analisis mengapa hasilnya seperti di atas !

Seperti source di atas, kita dapat mempunyai lebih dari satu

constructor, masing-masing harus mempunyai parameter yang
berbeda sebagai penandanya. Program secara otomatis akan memilih
constructor mana yang akan dijalankan sesuai dengan parameter
masukan pada waktu pembuatan objek. Hal seperti ini disebut
overloading terhadap constructor.

boolean byte char double float int long short public private
protected abstract final native static strictfp synchronized transient volatile if
else do while switch case default for break continue assert
class extends implements import instanceof interface new package super this
catch finally try throw throws return void const goto enum
-Jangan pernah menggunakan kata-kata ini sebagai nama variabel, jika terjadi maka compile akan
error -

Modul Praktikum PBO 32

 Modul 3 : AGREGASI DAN KOMPOSISI

3.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Mengerti konsep dasar object oriented programming
2. Memahami penggunaan kelas dalam pemrograman java
3. Memahami hubungan antar kelas baik asosiasi, agreasi dan komposisi.

3.2 Diagram Kelas

Diagram kelas merupakan sebuah diagram yang digunakan untuk memodelkan kelas-kelas yang
digunakan di dalam sistem beserta hubungan antar kelas dalam sistem tersebut.
Beberapa elemen penting dalam diagram kelas adalah kelas dan relasi antar kelas. Kelas digambarkan
dengan simbol kotak seperti gambar di bawah ini:

Gambar 3-1 Diagram Kelas

Baris pertama dari simbol diagram kelas menandakan nama dari kelas yang bersangkutan. Baris di
bawahnya menyatakan atribut-atribut dari kelas tersebut apa saja, dan baris setelahnya menyatakan
method-method yang terdapat pada kelas tersebut. Adapun simbol untuk access modifer adalah:
Simbol Keterangan
+ simbol access modifier public
- simbol access modifier private
# simbol access modifier protected (untuk simbol ini tidak terdapat pada gambar diatas)
Sedangkan untuk menggambarkan hubungan antar kelas digunakan simbol garis antara dua kelas yang
berelasi. Simbol garis tersebut antara lain:
- Class1 berasosiasi dengan Class2 , digambarkan sebagai berikut:
Class1 Class2

Gambar 3-2 Hubungan Asosiasi

- Class2 merupakan elemen part-of dari Class1 (Class1 berelasi agregasi dengan Class2),
digambarkan sebagai berikut:
Class1 Class2

Gambar 3-3 Hubungan Agregasi

Modul Praktikum PBO 33

 - Class1 dengan Class2 berelasi komposisi, digambarkan sebagai berikut:
Class1 Class2

1 *

Gambar 3-4 Hubungan Komposisi

- Class1 merupakan turunan dari Class2, digambarkan sebagai berikut:
Class1 Class2

Gambar 3-5 Hubungan Generalisasi

3.3 Hubungan Antar Kelas
Dalam Obyek Oriented Programming, kelas-kelas yang terbentuk dapat memiliki hubungan satu dengan
yang lainnya, sesuai dengan kondisi dari kelas-kelas yang bersangkutan. Ada beberapa jenis hubungan
yang dapat terjadi antara kelas yang satu dengan kelas yang lainnya, antara lain:
1. Asosiasi
2. Agregasi
3. Komposisi
4. Generalisasi dan Spesialisasi (terkait dengan pewarisan)
3.3.1 Asosiasi
Asosiasi merupakan hubungan antara dua kelas tidak konseptual terkait tetapi dalam konteks masalah
perlu memanfaatkan layanan masing-masing . Contoh dari hubungan asosiasi ini adalah:
Dosen Mahasiswa

1 *

Gambar 3-6 Contoh hubungan asosiasi

Pada diagram kelas di atas terlihat hubungan bahwa kelas dosen mengajar beberapa mahasiswa. Bentuk
implementasi dari diagram kelas tersebut di Java adalah sebagai berikut:
//mahasiswa.java
public class mahasiswa {
private String nim;
private String nama;
public void setnama (String nama) {
this.nama = nama;
}
public void setnim (String nim) {
this.nim = nim;
}
public String getnim () {
return this.nim;
}
public String getnama () {
return this.nama;
}
}

Modul Praktikum PBO 34

//dosen.java
public class dosen {
private String Kddosen;
private String[] nimMHS;
private int JmlMahasiswa;
public void setKddosen (String Kddosen) {
this.Kddosen = Kddosen;
}
public void setNimMahasiswa (String nimMhs) {
if (JmlMahasiswa<5) {
nimMHS[JmlMahasiswa] = nimMhs;
JmlMahasiswa++;
}
}
public int getJmlMahasiswa () {
return this.JmlMahasiswa;
}
public String getKddosen () {
return this.Kddosen;
}
public String getmahasiswa (int i) {
return (nimMHS[i]);
}
}
Pada implementasi terlihat bahwa tidak ada relasi yang kuat antara kelas dosen dan kelas mahasiswa,
hanya ada atribut dari kelas dosen yang serupa dengan atribut dari kelas mahasiswa yang menandakan
bahwa kedua kelas itu berasosiasi, yaitu atribut nimMahasiswa pada kelas dosen dan atribut nim pada
kelas mahasiswa.
3.3.2 Agregasi
Agregasi merupakan hubungan antara dua kelas yang lebih ketat dan terdapat hubungan bagian (part)
dan keseluruhan (whole). Contoh hubungan agregasi ini adalah:
Jurusan Mahasiswa

1 *

Gambar 3-7 Contoh hubungan agregasi

Pada diagram kelas di atas, terlihat hubungan antara kelas Jurusan dengan kelas Mahasiswa. Kelas
mahasiswa merupakan bagian dari kelas jurusan, tetapi kelas jurusan dan kelas mahasiswa dapat
diciptakan sendiri-sendiri.
Implementasi dari diagram kelas tersebut dalam Java adalah sebagai berikut:
//mahasiswa.java
public class mahasiswa {
private String NIM, Nama;
public mahasiswa(String no, String nm) {
this.NIM = no;
this.Nama = nm;
}
public String GetNIM() {
return (NIM);

Modul Praktikum PBO 35

 }
public String GetNama() {
return (Nama);
}
}

//jurusan.java
public class Jurusan {
private String KodeJurusan, NamaJurusan;
private Mahasiswa[] Daftar = new Mahasiswa[10];
public Jurusan(String kode, String nama) {
this.KodeJurusan = kode;
this.NamaJurusan = nama;
}
private static int JmlMhs = 0;
public void AddMahasiswa(Mahasiswa m) {
this.Daftar[JmlMhs] = m;
this.JmlMhs++;
}
public void DisplayMahasiswa() {
int i;
Sistem.out.println("Kode Jurusan : "+this.KodeJurusan);
Sistem.out.println("Nama Jurusan : "+this.NamaJurusan);
Sistem.out.println("Daftar Mahasiswa :");
for (i=0;i<JmlMhs;i++)
Sistem.out.println(Daftar[i].GetNIM()+" "+Daftar[i].GetNama());
}
}
Pada implementasi terlihat bahwa kelas jurusan memiliki atribut yang memiliki tipe kelas mahasiswa,
sehingga kelas mahasiswa merupakan bagian dari kelas jurusan.
3.3.3 Komposisi
Komposisi merupakan bentuk khusus dari agregasi dimana terdapat hubungan antar kelas yang lebih
kuat , karena yang menjadi part (bagian) tidak akan ada tanpa adanya kelas yang menjadi whole.
Contoh hubungan komposisi adalah sebagai berikut:

Komputer

1 1 1
→ 1 1 1

CPU Monitor Mouse

Gambar 3-8 Contoh hubungan komposisi

Modul Praktikum PBO 36

Dari diagram kelas di atas terlihat bahwa kelas CPU, Monitor, dan Mouse semuanya merupakan bagian
dari kelas Komputer dan ketika kelas Komputer musnah maka kelas CPU, Monitor, dan Mouse akan ikut
musnah.
Implementasi dari diagram kelas tersebut dalam Java adalah sebagai berikut:
Pada implementasi di atas, terlihat bahwa kelas CPU, Monitor, dan Printer merupakan atribut dari kelas
Komputer dan baru diciptakan pada saat instansiasi obyek dari kelas Komputer.
//CPU.java
public class CPU {
private String Merk;
private int Kecepatan;
public CPU(String m, int k) {
this.Merk = m;
this.Kecepatan = k;
}
public void DisplaySpecCPU() {
Sistem.out.println(this.Merk + ", " + this.Kecepatan);
}
}
//Monitor.java
public class Monitor {
private String Merk;
public Monitor(String m) {
this.Merk = m;
}
public void DisplaySpecMonitor() {
Sistem.out.println(this.Merk);
}
}
//Printer.java
public class Mouse {
private String Merk, Type;
public Printer(String m, String t) {
this.Merk = m;
this.Type = t;
}
public void DisplaySpecMouse() {
Sistem.out.println(this.Merk + ", " + this.Type);
}
}

Modul Praktikum PBO 37

 Modul 4 : INHERITANCE DAN POLYMORFISME

4.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Mengerti dan memahami inheritance secara mendalam.
2. Memahami konsep inheritance dan polymofisme serta dapat mengimplementasikan dalam suatu
program.

4.2 Pendahuluan
Pada dasarnya kita sebagai manusia sudah terbiasa untuk melihat objek yang berada di sekitar kita
tersusun secara hierarki berdasarkan kelas-nya masing-masing. Dari sini kemudian timbul suatu konsep
tentang pewarisan yang merupakan suatu proses dimana suatu class diturunkan dari kelas lainnya
sehingga ia mendapatkkan ciri atau sifat dari kelas tersebut.
Dari hirarki di atas, semakin ke bawah, kelas akan semakin bersifat spesifik. Misalnya, sebuah Kelas Pria
memiliki seluruh sifat yang dimiliki oleh manusia, demikian halnya juga Wanita.
Penurunan sifat tersebut dalam Bahasa Pemrograman Java disebut dengan Inheritance yaitu satu
dalam Pilar Dasar OOP (Object Oriented Programing), yang dalam implementasinya merupakan sebuah
hubungan “adalah bagian dari” atau “is a relationship” object yang diinherit (diturunkan).
Latar belakang diperlukannya suatu inheritance dalam pemrograman java adalah untuk menghindari
duplikasi object baik itu field, variable maupun method yang sebenarnya merupakan object yang bisa
diturunkan dari hanya sebuah kelas. Jadi inheritance bukan sebuah Kelas yang diturunkan oleh sebuah
Literial, tapi lebih menunjukkan ke hubungan antar object itu sendiri.
Sedangkan suatu kemampuan dari sebuah object untuk membolehkan mengambil beberapa bentuk
yang berbeda agar tidak terjadi duplikasi object kita kenal sebagai polymorphism.
Antara penurununan sifat (inheritance) maupun polymorphism merupakan konsep yang
memungkinkan digunakannya suatu interface yang sama
untuk memerintah objek agar melakukan aksi atau
tindakan yang mungkin secara prinsip sama namun
secara proses berbeda. Dalam konsep yang lebih umum
sering kali polymorphism disebut dalam istilah tersebut.

4.3 Inheritance
Inheritance merupakan suatu cara untuk menurunkan
suatu kelas yang lebih umum menjadi suatu kelas yang
lebih spesifik. Inheritance adalah salah satu ciri utama
suatu bahasa program yang berorientasi pada objek, dan
Java pasti menggunakannya. Java mendukung inheritance
dengan memungkinkan satu kelas untuk bersatu dengan
kelas lainnya ke dalam deklarasinya. Dalam inheritance
terdapat dua istilah yang sering digunakan. Kelas yang
menurunkan disebut kelas dasar (base class/super class), Gambar 4-1 Ilustrasi pada kelas
sedangkan kelas yang diturunkan disebut kelas turunan manusia

Modul Praktikum PBO 38

(derived class/subclass). Karakteristik pada superclass
akan dimiliki juga oleh subclassnya.
Manusia adalah superclass dari pria dan wanita. Pria dan wanita mewarisi state dan behaviour kelas
manusia.
Contoh pewarisan dalam program java:
class A
{
int x;
int y;
void tampilXY()
{
System.out.println("nilai x: "+x+" nilai y: "+y);
}
}

class B extends A
{
int z;
void jumlahXY()
{
System.out.println("jumlah: "+(x+y+z));
}
}
public class DemoInheritance
{
public static void main(String[] args) {
A superclass=new A();
B subclass=new B();
System.out.println("superclass :");
superclass.x=3;
superclass.y=4;
superclass.tampilXY();
System.out.println("subclass :");
//member superclass dapat diakses dari subclassnya
subclass.x=1;
subclass.y=2;
subclass.tampilXY();
//member tambahan hanya ada di subclass
subclass.z=5;
subclass.jumlahXY();
}
}

4.4 Polymorfisme
Polymorphism berasal dari bahasa Yunani yang berarti banyak bentuk. Dalam
PBO, konsep ini memungkinkan digunakannya suatu interface yang sama untuk
memerintah obyek agar melakukan aksi atau tindakan yang mungkin secara
prinsip sama namun secara proses berbeda.

Modul Praktikum PBO 39

Dalam konsep yang lebih umum sering kali polymorphism disebut dalam istilah satu interface banyak
aksi. Contoh yang konkrit dalam dunia nyata yaitu mobil.
Mobil yang ada dipasaran terdiri atas berbagai tipe dan berbagai merk, namun semuanya memiliki
interface kemudi yang sama, seperti: stir, tongkat transmisi, pedal gas dan rem. Jika seseorang dapat
mengemudikan satu jenis mobil saja dari satu merk tertentu, maka orang itu akan dapat mengemudikan
hamper semua jenis mobil yang ada, karena semua mobil tersebut menggunakan interface yang sama.
Interface yang sama tidak berarti cara kerjanya juga sama. Misal pedal gas, jika ditekan maka
kecepatan mobil akan meningkat, tapi proses peningkatan kecepatan ini berbeda-beda untuk setiap
jenis mobil. Dengan OOP maka dalam melakukan pemecahan suatu masalah kita tidak melihat
bagaimana cara menyelesaikan suatu masalah tersebut (terstruktur) tetapi obyek-obyek apa yang
dapat melakukan pemecahan masalah tersebut.
Sebagai contoh anggap kita memiliki departemen yang memiliki manager, sekretaris, petugas
administrasi data dan lainnya. Misal manager ingin memperoleh data dari bag administrasi maka
manager tersebut dapat menyuruh petugas bag administrasi untuk mengambilnya. Pada kasus tersebut,
manager tidak harus mengetahui bagaimana cara mengambil data tetapi manager bisa mendapatkan
data tersebut melalui obyek petugas administrasi.
Jadi untuk menyelesaikan suatu masalah dengan kolaborasi antar obyek-obyek yang ada karena setiap
obyek memiliki deskripsi tugasnya sendiri.

4.4.1 Overloading method

Di dalam java Anda diperbolehkan membuat dua atau lebih method dengan nama yang sama dalam
satu kelas, tetapi jumlah dan tipe data argumen masing – masing method haruslah berbeda satu
dengan yang lainnya. Hal itu yang dinamakan dengan Overloading Method.Contoh program:
class Lagu {
String pencipta;
String judul;

void IsiParam(String param1) {

judul = param1;
pencipta = "Tidak dikenal";
}

void IsiParam(String param1,String param2) {

judul = param1;
pencipta = param2;
}

void CetakKeLayar() {
System.out.println("Judul : " + judul + ", pencipta : " + pencipta);
}
}
class DemoOver2 {
public static void main(String[] args) {
Lagu d,e;
d = new Lagu();
e = new Lagu();

d.IsiParam("Lagu 1");

Modul Praktikum PBO 40

 e.IsiParam("kepastian yang kutunggu","GiGi");

d.CetakKeLayar();
e.CetakKeLayar();
}
}
Pada contoh program di atas, kita melakukan overloading terhadap method IsiParam(). Di mana
IsiParam() yang pertama menerima satu buah parameter bertipe String dan IsiParam() yang kedua
menerima dua buah parameter bertipe String. Sehinnga inilah hasil eksekusi program yang didapat:
Judul : Lagu 1, pencipta : Tidak dikenal
Judul : kepastian yang kutunggu: GiGi

4.4.2 Overriding method

Di dalam java, jika dalam suatu subclass Anda mendefinisikan sebuah method yang sama dengan yang
dimiliki oleh superclass, maka method yang Anda buat dalam subclass tersebut dikatakan meng-
override superclass-nya. Sehingga jika Anda mencoba memanggil method tersebut dari instance
subclass yang Anda buat, maka method milik subclass-lah yang akan dipanggil, bukan lagi method milik
superclass-nya.Contoh program:
class A {
public void tampilkanKeLayar() {
System.out.println("Method milik class A dipanggil...");
}
}
class B extends A {
public void tampilkanKeLayar() {
super.tampilkanKeLayar(); // method milik superclas dipanggil
System.out.println("Method milik class B dipanggil...");
}
}
class DemoInheritance {
public static void main(String[] args) {
B subOb = new B();
subOb.tampilkanKeLayar();
}
}
Output program diatas:
Method milik class A dipanggil...
Method milik class B dipanggil...

Terlihat pada contoh di atas, kelas B yang merupakan turunan dari kelas A, meng-override method
tampilkanKeLayar(), sehingga pada waktu kita memanggil method tersebut dari variable instance kelas
B (variable subOb), yang terpanggil adalah method yang sama yang ada pada kelas B.
4.5 Referensi Variabel Casting
Terdapat 2 tipe variabel reference yaitu Downcasting dan Upcasting.
Downcasting: apabila terdapat variabel reference yang mengacu pada subtipe objek, maka dapat
dimasukkan ke dalam subtipe variabel reference. Dengan kata lain downcasting hanya dapat dilakukan

Modul Praktikum PBO 41

bila antara type dari object dan type dari variabel reference masih dalam sebuah inheritance. Bila ada
polymorphisme sebagai berikut:
A ref = new B();
// Dimana B adalah subclass dari A, maka dari variabel ref kita hanya akan
dapat meng-invoke (menjalankan) method-method yang dideklarasikan di kelas
A. Bila kita ingin meng-invoke method yang hanya terdapat di kelas B, maka
kita tidak dapat secara langsung memanggil method yang hanya ada di B
seperti sebagai berikut:
ref.methodDiB(); //COMPILE TIME ERROR !!!!
Potongan program di atas akan menghasilkan compile time error sbb:
Cannot find symbol
Agar dapat meng-invoke method yang ada di kelas B, kita dapat menggunakan casting seperti sebagai
berikut:
//cara 1
B b = (B) ref; //CASTING !!!!
b.methodDiB();
//Atau :
//cara 2
((B)ref).methodDiB(); //CASTING !!!!

Contoh :
class A
{
void methodDiA()
{
System.out.println("A.methodDiA()");
}
}
class B extends A
{
void methodDiB()
{
System.out.println("B.methodDiB()");
}
}
class Polymorphisme01
{
public static void main(String[] args)
{
A ref = new B();

//cara 1
B b = (B) ref;
b.methodDiB();

//cara 2
((B)ref).methodDiB();
}
}

Modul Praktikum PBO 42

Program di atas akan menghasilkan :
B.methodDiB()
B.methodDiB()
Downcasting hanya dapat dilakukan bila antara type dari object dan type dari variabel reference masih
dalam sebuah inheritance. Bila tidak, maka akan terjadi compile time error (inconvertible types).
Contoh:
class A {}
class B extends A {}
class C {}
class Test
{
void lakukanSesuatu()
{
A ab = new B();
B b = (B) ab; //Downcast berhasil
C c = (C) ab; //Downcast GAGAL
}
}

Compile time error yang dihasilkan adalah :

inconvertible types
Ada kemungkinan downcast tidak error saat compile time, akan tetapi melemparkan
ClassCastException. Hal ini terjadi karena type dari object yang diassign ke suatu variabel
reference adalah superclass dari type dari variabel references tersebut. Contoh:
class A {}
class B extends A {}
class Test
{
public static void main(String[] args)
{
Test t = new Test();
t.lakukanSesuatu();
}
void lakukanSesuatu()
{
A a = new A();
/*Statement di bawah dapat dicompile, akan tetapi
*saat dijalankan akan melemparkan exception
*ClassCastException !!!!
*/
B b = (B) a;
}
}
/*
Saat dicompile berhasil !!! (dengan javac)
Saat dijalankan (dengan java) akan menghasilkan :
java.lang.NoClassDefFoundError: inheritance/VarRefCast03
Exception in thread "main"
Java Result: 1
*/

Modul Praktikum PBO 43

Kesimpulan untuk downcast adalah :
1. Downcast pasti explisit.
2. Downcast akan berhasil saat compile time bila antara object dengan variabel reference masih
dalam 1 buah jalur inheritance.
3. Downcast akan gagal saat runtime (melemparkan exception) bila ternyata type dari object yang
diassign ke variabel reference ternyata adalah superclass dari variabel reference itu.
Upcasting: mengisikan variabel reference ke variabel reference lainnya dengan tipe superclassnya.
Upcasting bisa dilakukan dengan dua cara :
1. Implisit upcasting (otomatis)
2. Eksplisit upcasting
Contoh : [1]
Program 08
class A {}
class B extends A {}
class VarRefCast01
{
public static void main(String[] args)
{
B b = new B();
//implisit upcasting
//dari variabel reference ke variabel reference lainnya
A ab1 = b;
//implisit upcasting
//dari suatu object ke variabel reference
A ab2 = new B();
//explisit upcasting
//dari variabel reference ke variabel reference lainnya
A ab3 = (A) b;
//explisit upcasting
//dari object kel variabel reference
A ab4 = (A) new B();
}
}

Modul Praktikum PBO 44

 Perhatikan kelas diagram disamping. Jawablah
pertanyaan dibawah ini!

1. Sebutkan method mana yang melakukan override?

2. Sebutkan method mana yang melakukan overload?

3. Buatlah syntax yang mengaplikasikan kelas

diagram tersebut.

Modul Praktikum PBO 45

 Modul 5 : INTERFACE DAN ABSTRACT

5.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Memahami dan mengerti konsep interface dan mampu mengimplementasikan dalam Java.
2. Memahami dan mengerti konsep abstract dan mampu mengimplementaskan dalam Java.
3. Mampu membedakan antara kelas abstract dan interface.

5.2 Interface
Interface serupa dengan kelas. Kelas mendefinisikan kemampuan sebuah object, sementara interface
mendefinisikan method atau konstanta yang akan diimplementasikan pada object yang lain. Interface
membantu mendefinisikan sifat object dengan mendeklarasikan seperangkat karakteristik object
tersebut. Sebagai contoh kasus, radio, TV, dan speaker komputer memiliki pengontrol volume. Untuk
alasan ini, mungkin kita menginginkan device-device ini mengimplementasikan interface yang bernama
VolumeControl.
Interface memiliki beberapa batasan:
• Semua atribut adalah public, static dan final (semua atribut bertindak sebagai konstanta)
• Semua method adalah abstract dan public.
• Tidak boleh ada deklarasi konstruktor.

Berbeda dengan class biasa, interface mengizinkan multiple inheritance, yaitu sebuah kelas dapat
mempunyai dua interface induk sekaligus. Hal tersebut tidak dapat dilakukan pada sebuah kelas,
dimana sebuah kelas hanya boleh mempunyai satu kelas induk.
Syntax yang diperlukan hampir sama dengan cara membuat kelas. Perbedaannya hanya method pada
interface tidak memiliki isi/ variable. Sebuah contoh dengan tiga item: interface, kelas yang
mengimplementasikan interface, dan kelas yang menggunakan kelas yang disalurkan. Sebagai ilustrasi
perhatikan gambar UML berikut:

Gambar 5-1 Contoh kelas interface dalam UML

Berdasarkan gambar diatas hirarki dimulai dengan interface Payable . Relasi UML yang terlihat antara
kelas dan interface dinamakan realization. Sebuah kelas dikatakan merealisasikan atau
mengimplementasikan method pada sebuah interface.
Berikut contoh program dari UML diatas (Hanya interface Payable dan Kelas Invoice) .
Interface Payable

Modul Praktikum PBO 46

 4 public interface Payable
5 {
6 double getPaymentAmount(); // calculate payment; no implementation
7 } // end interface Payable

Kelas Invoice yang mengimplementasikan Payable

public class Invoice implements Payable
5 {
6 private String partNumber;
7 private String partDescription;
8 private int quantity;
9 private double pricePerItem;
10
11 // four-argument constructor
12 public Invoice( String part, String description, int count,
13 double price )
14 {
15 partNumber = part;
16 partDescription = description;
17 setQuantity( count ); // validate and store quantity
18 setPricePerItem( price ); // validate and store price per item
19 } // end four-argument Invoice constructor
20
21 // set part number
22 public void setPartNumber( String part )
23 {
24 partNumber = part;
25 } // end method setPartNumber
26
27 // get part number
28 public String getPartNumber()
29 {
30 return partNumber;
31 } // end method getPartNumber
32
33 // set description
34 public void setPartDescription( String description )
35 {
36 partDescription = description;
37 } // end method setPartDescription
38
39 // get description
40 public String getPartDescription()
41 {
42 return partDescription;
43 } // end method getPartDescription
44
45 // set quantity
46 public void setQuantity( int count )
47 {
48 quantity = ( count <0 ) ? 0 : count; // quantity cannot be
negative
49 } // end method setQuantity
50
51 // get quantity
Modul Praktikum PBO 47
 52 public int getQuantity()
53 {
54 return quantity;
55 } // end method getQuantity
56
57 // set price per item
58 public void setPricePerItem( double price )
59 {
60 pricePerItem = ( price <0.0 ) ? 0.0 : price; // validate price
61 } // end method setPricePerItem
62
63 // get price per item
64 public double getPricePerItem()
65 {
66 return pricePerItem;
67 } // end method getPricePerItem
68
69 // return String representation of Invoice object
70 public String toString()
71 {
72 return String.format( "%s: \n%s: %s (%s) \n%s: %d \n%s: $%,.2f",
73 "invoice", "part number", getPartNumber(),
getPartDescription(),
74 "quantity", getQuantity(), "price per item",
getPricePerItem() );
75 } // end method toString
76
77 // method required to carry out contract with interface Payable
78 public double getPaymentAmount()
79 {
80 return getQuantity() * getPricePerItem(); // calculate total cost
81 } // end method getPaymentAmount
82 } // end class Invoice

Modul Praktikum PBO 48

 public interface Product {
static final String MAKER = "My Corp";
static final String PHONE = "555-123-4567";
public int getPrice(int id);
}
public class Shoe implements Product {
public int getPrice(int id) {
if (id == 1)
return(5);
else
return(10);
}

public String getMaker() {

return(MAKER);
}
}
public class Store {
static Shoe hightop;
public static void init() {
hightop = new Shoe();
}
}
public static void main(String argv[]) {
init();
getInfo(hightop);
orderInfo(hightop);
}
public static void getInfo(Shoe item) {
System.out.println("This Product is made by "+ item.MAKER);
System.out.println("It costs $" + item.getPrice(1) + '\n');
}
public static void orderInfo(Product item) {
System.out.println("To order from "+item.MAKER+" call "+item.PHONE+".");
System.out.println("Each item costs $"+item.getPrice(1));
}
}

5.3 Kelas Abstrak

Kata kunci abstrak digunakan untuk method atau class yang belum memiliki implementasi. Abstrak
method dideklarasikan pada abstrak class. Kelas yang dideklarasikan sebagai abstrak tidak akan bisa
dibentuk object dalam Java. Jadi kelas abstrak tidak akan bisa digunakan di dalam program kita yang
lain, kecuali kelas abstrak tersebut diturunkan dan turunan dari kelas abstrak tersebut yang bisa
dijadikan object. Sebagai ilustrasi dari kelas abstrak perhatikan gambar di bawah ini :

Gambar 5-2 Contoh kelas abstrak dalam UML

Modul Praktikum PBO 49

Gambar 5-2 menggunakan kelas Employee untuk merepresentasikan konsep umum pegawai. Kelas
Employee diperluas ke kelas SalariedEmployee, CommissionEmployee dan HourlyEmployee.
BasePlusCommissionEmployee yang memperluas CommisionEmployee merepresentasikan tipe akhir
pegawai. Berdasarkan gambar kelas Employee diketik miring menandakan bahwa kelas tersebut
merupakan kelas abstrak.
Berikut contoh program dari kelas abrak employee dan Kelas SalariedEmployee.
Kelas Abstrak Employee
public abstract class Employee
5 {
6 private String firstName;
7 private String lastName;
8 private String socialSecurityNumber;
9
10 // three-argument constructor
11 public Employee( String first, String last, String ssn )
12 {
13 firstName = first;
14 lastName = last;
15 socialSecurityNumber = ssn;
16 } // end three-argument Employee constructor
17
18 // set first name
19 public void setFirstName( String first )
20 {
21 firstName = first;
22 } // end method setFirstName
23
24 // return first name
25 public String getFirstName()
26 {
27 return firstName;
28 } // end method getFirstName
29
30 // set last name
31 public void setLastName( String last )
32 {
33 lastName = last;
34 } // end method setLastName
35
36 // return last name
37 public String getLastName()
38 {
39 return lastName;
40 } // end method getLastName
41
42 // set social security number
43 public void setSocialSecurityNumber( String ssn )
44 {
45 socialSecurityNumber = ssn; // should validate
46 } // end method setSocialSecurityNumber
47
48 // return social security number
49 public String getSocialSecurityNumber()

Modul Praktikum PBO 50

 50 {
51 return socialSecurityNumber;
52 } // end method getSocialSecurityNumber
53
54 // return String representation of Employee object
55 public String toString()
56 {
57 return String.format( "%s %s\nsocial security number: %s",
58 getFirstName(), getLastName(), getSocialSecurityNumber()
);
59 } // end method toString
60
61 // abstract method overridden by subclasses
62 public abstract double earnings(); // no implementation here
63 } // end abstract class Employee

Kelas SalariedEmployee yang merupakan turunan dari Kelas Abstrak.

public class SalariedEmployee extends Employee
5 {
6 private double weeklySalary;
7
8 // four-argument constructor
9 public SalariedEmployee( String first, String last, String ssn,
10 double salary )
11 {
12 super( first, last, ssn ); // pass to Employee constructor
13 setWeeklySalary( salary ); // validate and store salary
14 } // end four-argument SalariedEmployee constructor
15
16 // set salary
17 public void setWeeklySalary( double salary )
18 {
19 weeklySalary = salary <0.0 ? 0.0 : salary;
20 } // end method setWeeklySalary
21
22 // return salary
23 public double getWeeklySalary()
24 {
25 return weeklySalary;
26 } // end method getWeeklySalary
27
28 // calculate earnings; override abstract method earnings in
Employee
29 public double earnings()
30 {
31 return getWeeklySalary();
32 } // end method earnings
33
34 // return String representation of SalariedEmployee object
35 public String toString()
36 {
37 return String.format( "salaried employee: %s\n%s: $%,.2f",
38 super.toString(), "weekly salary", getWeeklySalary() );

Modul Praktikum PBO 51

 39 } // end method toString
40 } // end class SalariedEmployee

Perbedaan abstract class dan interface antara lain:

1. Semua interface method tidak memiliki body sedangkan beberapa abstract class dapat
memiliki method dengan implementasi.
2. Sebuah interface hanya dapat mendefinisikan constant sedangkan sebuah abstract class
tampak seperti kelas biasa yang dapat mendeklarasikan variable.
3. Interface tidak memiliki hubungan inheritance secara langsung dengan sebuah kelas tertentu,
sedangkan abstract class bisa jadi hasil turunan dari abstract class induknya.
4. Interface memungkinkan terjadinya pewarisan jamak (Multiple inheritance) sedangkan
abstract class tidak.
5.4 Keyword super
Keyword super digunakan untuk merefer superclass dari suatu kelas, yaitu untuk merefer member dari
suatu superclass, baik atribut maupun method.
Contoh :

Gambar 5-3 Contoh kelas dengan keyword super

Dari UML diatas dapat dilihat bahwa kelas Employee merupakan superclass dari kelas Manager.
class Employee {
private String name;
String departemen;
public Employee (String s) {
name = s;
}

public void tampilNama()

{
System.out.println("nama : "+name);
}
}
class Manager extends Employee {
private String alamat;

public Manager(String nama, String s) {

/*memanggil konstruktor employee*/
super(nama);
alamat = s;
}
public void tampilAlamat()
{

Modul Praktikum PBO 52

 /*menginisialisasi variabel departemen yang ada pada superclass*/
super.departemen="Personalia";
/*memanggil method tampilNama() yang ada pada superclass*/
super.tampilNama();
/*menampilkan variabel departemen yang telah diinisialisasi*/
System.out.println("alamat : "+alamat);
System.out.println("departemen : "+super.departemen);
}
public static void main(String[] args)
{
/*membuat objek*/
Manager adi = new Manager("adi","sukabirus");
adi.tampilAlamat();
}
}

Output Program :
Nama : adi
Alamat : sukabirus
Departemen : Personalia

Modul Praktikum PBO 53

 Modul 6 : Inner Class, Collection, dan Generics

6.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Menjelaskan pengertian inner class dan menjelaskan penggunaannya
2. Menjelaskan pengertian collection dan menjelaskan jenis-jenis collection serta perbedaan
penggunaannya
3. Menjelaskan pengertian generics dan menjelaskan penggunaan generics

6.2 Inner Class

Inner class adalah kelas yang didefinisikan di dalam sebuah kelas lainnya. Dengan didefinisikan di dalam
sebuah kelas, inner class memiliki akses khusus ke kelas yang melingkupinya. Inner class bahkan dapat
mengakses atribut/method dari kelas yang melingkupinya, walaupun bersifat private. Contoh
penggunaan inner class sebagai berikut:

public class MyOuter{

private int x = 0;
private MyInner inner;
public void outerMethod(){
inner = new MyInner();
inner.innerMethod();
}
public int getX(){
return x;
}
public class MyInner{
public void innerMethod(){
x = 10;
}
}
}
public class Driver{
public static void main(String args[]){
MyOuter outer = new MyOuter();
outer.outerMethod();
System.out.println(outer.getX());
}
}

Obyek dari inner class tidak bisa berdiri sendiri. Untuk membentuk obyek dari inner class, dibutuhkan
obyek dari outer class terlebih dahulu.

Modul Praktikum PBO 54

6.2.1 Mendefinisikan Inner Class
Terdapat tiga cara yang dapat digunakan untuk mendefinisikan inner class.

1. Definisi inner class di dalam body class

Cara pertama adalah dengan mendefinisikan inner class di dalam body class. Perhatikan contoh
berikut:

// file: OuterDemo.java
public class OuterDemo {
private int num;
class InnerDemo {
public void print() {
System.out.println("This is an inner class");
}
public int getNum() {
return num;
}
}
}

// file: MyClass1.java
public class MyClass1 {
public static void main(String[] args) {
OuterDemo.InnerDemo inner =
new OuterDemo().new InnerDemo();
inner.print();
System.out.println("Num = "+inner.getNum());
}
}

Pemanggilan obyek dari inner class harus dilakukan dari obyek kelas yang melingkupinya. Seperti
pada contoh di atas, untuk memanggil obyek dari kelas InnerDemo harus dilakukan pemanggilan
obyek OuterDemo terlebih dahulu.

2. Definisi inner class di dalam body method

Cara kedua adalah dengan mendefinisikan inner class di dalam body method. Hal ini sering disebut
juga dengan local class. Contohnya seperti berikut.

// file: OuterClass.java
public class OuterClass {
void myMethod() {
int num = 23;
class MethodInnerDemo {
public void print() {

Modul Praktikum PBO 55

 System.out.println("The number = "+num);
}
}
MethodInnerDemo mid = new MethodInnerDemo();
mid.print();
}
public static void main(String[] args) {
OuterClass oc = new OuterClass();
oc.myMethod();
}
}

Karena kelas MethodInnerDemo didefinisikan di dalam method myMethod(), maka kelas tersebut
hanya dikenali di dalam method myMethod() dan tidak dapat didefinisikan di luar method
myMethod().

3. Definisi inner class menggunakan anonymous class

Cara ketiga mendefinisikan inner class adalah menggunakan anonymous class. Anonymous class
adalah kelas yang tidak didefinisikan namanya. Contoh penggunaannya sebagai berikut.

// file: OuterClass2.java
abstract class AnonymousInner {
public abstract void mymethod();
}

public class OuterClass2 {

public static void main(String[] args) {
AnonymousInner inner = new AnonymousInner {
@Override
public void mymethod() {
System.out.println("Anonymous class sample");
}
}
inner.mymethod();
}
}

Perhatikan kode di atas. Terlihat bahwa obyek inner yang dipanggil di dalam method main adalah
obyek yang berasal dari penurunan kelas abstrak AnonymousInner. Namun kelas yang
menurunkannya tidak diberikan nama, karena pendefinisiannya langsung menggunakan constructor
AnonymousInner dengan meng-override method abstrak.

Cara lain untuk mendefinisikan anonymous class adalah sebagai berikut.

Modul Praktikum PBO 56

 // file: MyClass2.java
interface Message {
String greet();
}

public class MyClass2 {

public void displayMessage(Message m) {
System.out.println(m.greet()+", how do you do?");
}
public static void main(String[] args) {
MyClass2 obj = new MyClass2();
obj.displayMessage(new Message(){
@Override
public String greet() {
return "Hello";
}
});
}
}

Pada contoh di atas, pendefinisian anonymous class dilakukan pada saat pemanggilan method
displayMessage() oleh obyek obj. pendefinisian dilakukan di dalam parameter method
displayMessage().

6.3 Collection
Collection adalah obyek khusus yang digunakan untuk menampung banyak obyek yang bertipe apapun.
Collection dapat menampung banyak obyek bertipe Object. Seperti diketahui, semua kelas di Java
merupakan turunan dari kelas Object, maka dengan prinsip polimorfisme, collection dapat menampung
obyek bertipe apapun.

Collection didefinisikan sebagai interface. Kita dapat menggunakan kelas turunan dari Collection. Berikut
adalah hirarki yang ada pada Collection.

Modul Praktikum PBO 57

 Gambar 6.1 Hirarki dari Collection

Dengan menggunakan generics, kita dapat membatasi tipe yang dapat ditampung oleh Collection.
Contohnya sebagai berikut.

Collection<String> str = new HashSet<String>();

List<Integer> arr_i = new List ();
ArrayList<Employee> emp = new ArrayList ();

Beberapa method yang ada pada Collection antara lain:

Tabel 6.1 Beberapa method Collection

Nama Method Deskripsi

boolean add(Object item) Menambahkan item ke dalam collection
boolean remove(Object item) Menghapus item dari dalam collection
boolean addAll(Collection c) Menambahkan semua item dari c ke dalam collection
boolean removeAll(Collection c) Menghapus semua item yang ada pada c dari dalam collection
boolean retainAll(Collection c) Menghapus semua item yang tidak ada pada c dari dalam collection
boolean contains(Object item) Mengecek apakah item ada di dalam collection

Modul Praktikum PBO 58

Terdapat beberapa cara yang dapat digunakan untuk mengakses semua elemen dari Collection.

import java.util.*;

public class JavaApplication1 {

public static void main(String[] args) {

List list = new ArrayList();
list.add(200);
list.add("Hello");
list.add(235);
list.add("Donny");

// normal loop
System.out.println("Normal loop");
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
System.out.println(o);
}

// loop using for-element

System.out.println("for-element loop");
for (Object o : list) {
System.out.println(o);
}

// Loop using iterator

System.out.println("loop using iterator");
Iterator itr = list.iterator();
while (itr.hasNext()) {
Object o = itr.next();
System.out.println(o);
}

// loop using lambda Expression

System.out.println("loop using lambda expression");
list.forEach(o -> System.out.println(o));

// loop using reference

System.out.println("loop using reference");
list.forEach(System.out::println);

Modul Praktikum PBO 59

}

6.3.1 Melakukan Sorting pada Collection

Untuk melakukan sorting pada Collection, kita dapat menggunakan du acara:

1. Menggunakan interface Comparable

Untuk melakukan sorting, dapat menggunakan method Collections.sort(list) atau list.sort(). Jika list
mengandung elemen bertipe String, maka list akan diurutkan berdasarkan urutan abjad. Jika list
mengandung elemen bertipe Date, maka list akan diurutkan berdasarkan urutan tanggal. Untuk
membangun pengurutan sendiri pada list bertipe kelas tertentu, maka kelas tersebut harus
mengimplementasikan interface Comparable dan meng-override method compareTo(Object obj).
Method compareTo(Object obj) akan mengembalikan:
1. Nilai < 0, jika obyek yang memanggil diurutkan sebelum obyek obj
2. Nilai = 0, jika obyek yang memanggil sama dengan obyek obj
3. Nilai > 0, jika obyek yang memanggil diurutkan setelah obyek obj
Jika parameter pada compareTo adalah String atau Date, maka pada compareTo panggil:
return this.getString().compareTo(obj.getString())
Jika parameter pada compareTo adalah angka, maka pada compareTo lakukan pengurangan,
seperti:
return this.getNumber() – obj.getNumber()
Contoh penggunaan interface Comparable sebagai berikut.

import java.util.*;

public class Employee implements Comparable<Employee> {

private String name;
private int salary;
public Employee(String name, int salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public int getSalary() {
return salary;
}
@Override
public String toString() {
return "name=" + name + ", salary=" + salary;
}

Modul Praktikum PBO 60

 @Override
public int compareTo(Employee e) {
return name.compareTo(e.name);
}
public static void main(String[] args) {
List<Employee> listEmp = new ArrayList();
listEmp.add(new Employee("bobby", 3000));
listEmp.add(new Employee("erick", 1600));
listEmp.add(new Employee("rey", 2500));
listEmp.add(new Employee("anna", 3500));
Collections.sort(listEmp);
listEmp.forEach(System.out::println);
}
}

Output yang muncul sebagai berikut:

name=anna, salary=3500.0
name=bobby, salary=3000.0
name=erick, salary=1600.0
name=rey, salary=2500.0

2. Menggunakan interface Comparator<T>

Interface comparable memungkinkan untuk melakukan sorting pada satu property saja. Untuk
melakukan sorting pada multiple property, gunakan interface Comparator. Caranya adalah dengan
membuat kelas yang mengimplementasikan interface Comparator<T> dan meng-override method
compare(T obj1, T obj2). Contohnya kita dapat membangun kelas comparator untuk kelas
Employee sebagai berikut:

import java.util.*;

public class SalaryComparator implements Comparator<Employee> {

@Override
public int compare(Employee e1, Employee e2) {
return e1.getSalary() - e2.getSalary();
}
}

Penggunaan kelas comparator pada method main sebagai berikut.

public static void main(String[] args) {

List<Employee> listEmp = new ArrayList();
listEmp.add(new Employee("bobby", 3000));
listEmp.add(new Employee("erick", 1600));

Modul Praktikum PBO 61

 listEmp.add(new Employee("rey", 2500));
listEmp.add(new Employee("anna", 3500));
Collections.sort(listEmp);
System.out.println("Sorted by name");
listEmp.forEach(System.out::println);
Collections.sort(listEmp, new SalaryComparator());
System.out.println("Sorted by salary");
listEmp.forEach(System.out::println);
}

Output yang dihasilkan sebagai berikut.

Sorted by name
name=anna, salary=3500
name=bobby, salary=3000
name=erick, salary=1600
name=rey, salary=2500
Sorted by salary
name=erick, salary=1600
name=rey, salary=2500
name=bobby, salary=3000
name=anna, salary=3500

6.3.2 Melakukan Filtering pada Collection

Untuk melakukan filtering pada Collection, kita dapat menggunakan dua cara. Misalkan kita ingin
melakukan filtering pada list Employee berdasarkan kriteria tertentu. Misalkan kita ingin mencari daftar
Employee yang memiliki gaji minimal 3000. Maka, kita dapat menggunakan dua cara.
1. Menggunakan cara konvensional seperti berikut.
System.out.println("Employee with salary minimal 3000");
for(Employee e: listEmp) {
if(e.getSalary() >= 3000) {
System.out.println(e);
}
}

2. Menggunakan ekspresi lambda seperti berikut.

System.out.println("Employee with salary minimal 3000");
List<Employee> temp = listEmp.stream().
filter(e -> e.getSalary() >= 3000).collect(Collectors.toList());
temp.forEach(System.out::println);

Atau kita ingin mencari Employee dengan nama tertentu. Maka kita dapat menggunakan dua cara.
1. Menggunakan cara konvensional seperti berikut.

Modul Praktikum PBO 62

 System.out.println("Employee erick");
for(Employee e: listEmp) {
if(e.getName().equals("erick")) {
System.out.println(e);
}
}

2. Menggunakan ekspresi lambda seperti berikut.

System.out.println("Employee erick");
System.out.println(listEmp.stream().
filter(e -> e.getName().equals("erick")).
findFirst().orElse(null));

6.4 Generics
Generic adalah sebuah cara untuk memberikan batasan tipe kepada sebuah kelas atau fungsi. Tipe
generic dideklarasikan di dalam kelas dan didefinisikan saat instansiasi. Compiler akan mengganti semua
kemunculan parameter bertipe kelas tertentu dengan upperbound dari tipe parameter formalnya.
Secara default, upperbound yang digunakan adalah tipe Object.

import java.util.*;

public class MyGenerics<E> {

private List<E> list = new ArrayList<>();
public int getSize() {
return list.size();
}
public void insert(E item) {
list.add(item);
}
public void printAll() {
list.forEach(System.out::println);
}
public static void main(String[] args) {
class Building {
String address;
Building(String address) {
this.address = address;
}
@Override
public String toString() {
return "address: "+address;
}

Modul Praktikum PBO 63

 }
MyGenerics<Building> building = new MyGenerics<>();
building.insert(new Building("Jl Margahayu Raya no. 30"));
building.insert(new Building("Jl Cisaranten no. 17"));
building.insert(new Building("Jl Banteng no. 25"));
building.insert(new Building("Jl Solokan Jeruk no. 14"));
building.insert(new Building("Jl Telekomunikasi no. 6"));
building.printAll();
}
}

Penggunaan wildcard <E> pada kelas MyGeneric akan membatasi kelas MyGeneric sesuai tipe yang
diberikan pada E. Contoh pada method main, tipe E diganti dengan tipe Building, maka kelas Building
akan menjadi upperbound dari kelas MyGeneric. Sehingga, obyek building hanya akan menerima obyek
bertipe Building. Kita juga bisa menggunakan unbounded wildcard untuk memberikan batasan yang
lebih luas kepada sebuah generic. Contohnya sebagai berikut.

import java.util.*;

public class GenericMethod {

public static double average(List<? extends Number> list) {
double sum = 0;
for(Number num:list) {
sum += num.doubleValue();
}
return sum/list.size();
}
public static void main(String[] args) {
List<Integer> number1 = new LinkedList<>();
number1.add(45);
number1.add(75);
number1.add(35);
System.out.println("Average number1 = "+average(number1));

List<Double> number2 = new ArrayList<>();

number2.add(49.23);
number2.add(22.11);
number2.add(32.73);
System.out.println("Average number2 = "+average(number2));
}
}

Modul Praktikum PBO 64

Penggunaan unbounded wildcard <?> pada deklarasi method average menyebabkan parameter pada
method average dapat menerima parameter bertipe List dengan isi elemen apapun selama masih
merupakan turunan dari kelas Number. Dengan adanya unbounded wildcard, kita dapat memperluas
definisi dari tipe generic yang kita inginkan, tidak hanya satu tipe saja seperti pada contoh di atas.

Modul Praktikum PBO 65

 Modul 7 : Graphical User Interface (GUI)

7.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Mengenal komponen-komponen dasar dalam pembuatan user interface dalam Java.
2. Mengerti konsep Graphic User Interface dalam Java dan dapat mengimplementasikannya dalam
sebuah program sederhana.

7.2 AWT and Swing

AWT(Abstract Windowing Toolkit) dan Swing pada dasarnya adalah sama untuk membagun GUI pada
Java. AWT terdapat dalam package java.awt. Package ini berisi komponen-komponen GUI yang bersifat
platform oriented atau tergantung pada suatu platform system operasi. Swing ada pada package
javax.swing dan bersifat lightweight, yaitu dapat diaplikasikan untuk semua platform (multiplatfrom).
Dalam perkembanganya Swing lebih mendominasi dari pada Awt. Hal ini dapat dilihat banyaknya
komponen Swing yang tersedia dibandingkan komponen AWT.
Beberapa fasilitas yang disediakan oleh kedua kelas tersebut adalah sebagai berikut:
• Pengaturan tata letak (layout management) komponen dalam suatu container.
• Mendukung event handling, yaitu mekanisme pendeteksian event dan penentuan respons yang
akan diberikan ketika pengguna (user) mengakses komponen tersebut.
• Manipulasi grafis komponen seperti font, warna, icon, dll.

7.3 AWT components

- Label - TextField
- Checkbox - ScrollBar
- Choice - TextArea
- List - ScrollPanel
- MenuItem - Canvas

7.4 Swing components

Komponen Swing hampir sama dengan yang ada di Awt, namun ada penambahan fiture pada
Swing(other) .

Gambar 7-1 Komponen Swing

7.5 Komponen utama dalam GUI

• Containers: tempat dimana componen lain bisa di tempatkan didalamnya, contohnya adalah panel.
• Canvases. Digunakan untuk menampilkan image atau pembuatan program yang berbasis grafik. Kita
bisa menggambar titik, lingkaran dan sebagainya.

Modul Praktikum PBO 66

• UIcomponents. contohnya buttons, lists, simple pop-up menus, check boxes, text fields, dan elemen
khusus lain untuk user interface.
• Window contsruction components. Contohnya windows, frames, menu bars, dan dialog boxes.

7.6 The Basic User Interface Components with Swing

Secara umum terdapat 5 bagian Swing akan sering digunakan :
• Top-Level Container
Container dasar dimana komponen lain diletakkan.
Ex : Frame (JFrame), Dialog (JDialog) & Applet (JApplet)
• Intermediate Container
Container perantara dimana komponen lain diletakkan
Ex : JPanel, dimana umumnya hanya digunakan sebagai tempat untuk
meletakkan/mengelompokkan komponen-komponen yang digunakan, baik container atau berupa
atomic component. Dan digunakan juga sebagai scroll pane (JScrollPane & JTabbed Pane).
• Atomic Component
Komponen yang memiliki fungsi spesifik, dimana umumnya user langsung berinteraksi dengan
komponen ini
Ex : JButton, JLabel, JTextField, JTextArea.

7.7 Top Level Container

• Frame (JFrame) : Constructor yang dapat digunakan untuk membuat frame adalah JFrame() dan
JFrame(String title). Contoh penggunaannya adalah sbb:

import javax.swing.*;
public class FrameDemo {
public static void main(String[] args) {
JFrame frame = new JFrame("Frame Demo");
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
frame.setSize(400,150);
frame.show();
}
}

Class JFrame mendefinisikan 4 aktifitas yaitu:

o DO_NOTHING_ON_CLOSE
Tidak ada aktivitas apapun yang dilakukan secara otomatis jika kita menutup frame tsb.
Biasanya digunakan jika kita ingin menangani sendiri aktivitas tsb
o HIDE_ON_CLOSE
Merupakan aktivitas default, dimana frame hanya disembunyikan atau tidak ditampilkan
ke layar, namun secara fisik frame ini masih ada di memori sehingga jika diinginkan dapat
ditampilkan kembali.
o DISPOSE_ON_CLOSE
Menghapus tampilan frame dari layar, menghapusnya dari memori & membebaskan
resource yang dipakai
o EXIT_ON_CLOSE
Menghentikan eksekusi program. Cocok digunakan untuk frame utama, dimana jika frame
tsb ditutup mengakibatkan eksekusi program berhenti

Modul Praktikum PBO 67

• Dialog (JDialog): Perbedaan utama Frame dengan Dialog adalah: Dialog tidak berdiri sendiri (biasa
dibuat bersama dengan frame sebagai parentnya sehingga Dialog akan dihapus dari memori jika
Frame parentnya juga dihapus). Dialog bersifat modal (memblok semua input terhadap parentnya
sampai Dialog tersebut ditutup). Contoh penggunaanya adalah sbb:

import javax.swing.*;
public class DialogDemo {
public static void main(String[] args) {
JFrame frame = new JFrame("Contoh Frame"); //frame sbg parent bagi dialog
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.show();

JOptionPane.showConfirmDialog(frame,
"Contoh dialog konfirmasi ...", //Informasi dialog
"Judul Dialog", //judul dialog
JOptionPane.OK_CANCEL_OPTION, //Jenis Tombol
JOptionPane.QUESTION_MESSAGE);//Icon
}
}

7.8 Pengaturan Layout:

• Pengaturan dengan BorderLayout
• Pengaturan dengan BoxLayout
• Pengaturan dengan CardLayout
• Pengaturan dengan FlowLayout
• Pengaturan dengan GridLayout
• Pengaturan dengan GridBagLayout
• Pengaturan dengan GroupLayout
• Pengaturan dengan SpringLayout

7.8.1 Pengaturan dengan BorderLayout

BorderLayout adalah kelas yang menempatkan komponen dengan pendekatan arah mata angin. Pada
program dibawah ini kelima tombol diletakkan pada posisi yang berbeda-beda, ditentukan konstanta:
NORTH, EAST, SOUTH, WEST, CENTER.

Gambar 7-2 BorderLayout

SourceCodenya:
//file BorderLayoutDemo.java
import javax.swing.*;
import java.awt.*;

public class BorderLayoutDemo {

public static void main(String[] args) {
JFrame frame = new JFrame ("Contoh Border Layout");
BorderLayout layout = new BorderLayout(1,1);
frame.getContentPane().setLayout(layout);

Modul Praktikum PBO 68

 JButton btnNorth = new JButton("Posisi NORTH");
JButton btnSouth = new JButton("Posisi SOUTH");
JButton btnEast = new JButton("Posisi EAST");
JButton btnWest = new JButton("Posisi WEST");
JButton btnCenter = new JButton("Posisi CENTER");
frame.getContentPane().add(btnNorth,BorderLayout.NORTH);
frame.getContentPane().add(btnSouth,BorderLayout.SOUTH);
frame.getContentPane().add(btnEast,BorderLayout.EAST);
frame.getContentPane().add(btnWest,BorderLayout.WEST);
frame.getContentPane().add(btnCenter,BorderLayout.CENTER);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
}
}

7.8.2 Pengaturan dengan BoxLayout

BoxLayout meletakkan komponen- komponen dalam satu baris atau kolom saja

Gambar 7-3 BoxLayout

SourceCodenya:
//file BoxLayoutDemo.java
import javax.swing.*;
import java.awt.*;

public class BoxLayoutDemo {

public static void main(String[] args) {
JFrame frame = new JFrame ("BoxLayoutDemo");
Box comp = new Box(BoxLayout.Y_AXIS); //X_AXIS

JButton btn1 = new JButton("Button 1");

JButton btn2 = new JButton("Button 2");
JButton btn3 = new JButton("Button 3");
JButton btn4 = new JButton("Long Named Button 4");
JButton btn5 = new JButton("Button 5");
btn1.setAlignmentX(Component.CENTER_ALIGNMENT);
btn2.setAlignmentX(Component.CENTER_ALIGNMENT);
btn3.setAlignmentX(Component.CENTER_ALIGNMENT);
btn4.setAlignmentX(Component.CENTER_ALIGNMENT);
btn5.setAlignmentX(Component.CENTER_ALIGNMENT);
comp.add(btn1);
comp.add(btn2);
comp.add(btn3);
comp.add(btn4);
comp.add(btn5);
frame.getContentPane().add(comp);

Modul Praktikum PBO 69

 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
}
}

7.8.3 Pengaturan dengan CardLayout

CardLayout berguna untuk menampilkan objek Container seperti tumpukan kartu. Oleh karena itu,
hanya satu Container yang tertampil untuk setiap waktu.

Gambar 7-4 CardLayout

Source codenya:
import javax.swing.*;
import java.awt.*;
public class CardLayoutDemo {
public static void main(String[] args) {
JFrame frame = new JFrame ("CardLayoutDemo");
JPanel panel1 = new JPanel();
JPanel panel2 = new JPanel();
JButton btn1 = new JButton("Tombol 1");
JButton btn2 = new JButton("Tombol 2");
JTextField text1 = new JTextField(20);
panel1.add(btn1);
panel1.add(btn2);
panel2.add(text1);
JTabbedPane tab = new JTabbedPane();
tab.add(panel1,"Tab dengan Button");
tab.add(panel2,"Tab dengan TextField");
frame.getContentPane().add(tab,BorderLayout.NORTH);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300,150);
frame.show();
}
}

7.8.4 Pengaturan dengan FlowLayout

FlowLayout melakukan pengaturan komponen – komponen dalam objek Container dengan urutan dari
kiri ke kanan dan dari atas ke bawah. Pengaturan rata kiri, rata kanan, atau rata tengah bisa dilakukan
dengan melibatkan konstanta LEFT, RIGHT, CENTER.

Gambar 7-5 FlowLayout

Modul Praktikum PBO 70

Source Codenya
import javax.swing.*;
import java.awt.*;

public class FlowLayoutDemo {

public static void main(String[] args) {
JFrame frame = new JFrame ("FlowLayoutDemo");
FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
layout.setVgap(20); //jarak vertikal antar komponen
layout.setHgap(10); //jarak horisontal antar komponen
frame.getContentPane().setLayout(layout);
JButton btn1 = new JButton("Button 1");
JButton btn2 = new JButton("Button 2");
JButton btn3 = new JButton("Button 3");
JButton btn4 = new JButton("Long-Named Button 4");
JButton btn5 = new JButton("Button 5");
frame.getContentPane().add(btn1);
frame.getContentPane().add(btn2);
frame.getContentPane().add(btn3);
frame.getContentPane().add(btn4);
frame.getContentPane().add(btn5);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300,150);
frame.show();
}
}

7.8.5 Pengaturan dengan GridLayout

GridLayout merupakan manajer tataletak komponen yang menggunakan bentuk grid dengan ukuran
yang sama untuk setiap komponen.

Gambar 7-6 GridLayout

Source Codenya:
import javax.swing.*;
import java.awt.*;
public class GridLayoutDemo {
public static void main(String[] args) {
JFrame frame = new JFrame ("GridLayoutDemo");
GridLayout layout = new GridLayout(3,2);
layout.setHgap(5);
layout.setVgap(10);
frame.getContentPane().setLayout(layout);
JButton btn1 = new JButton("Button 1");
JButton btn2 = new JButton("Button 2");
JButton btn3 = new JButton("Button 3");

Modul Praktikum PBO 71

 JButton btn4 = new JButton("Long-Named Button 4");
JButton btn5 = new JButton("Button 5");
frame.getContentPane().add(btn1);
frame.getContentPane().add(btn2);
frame.getContentPane().add(btn3);
frame.getContentPane().add(btn4);
frame.getContentPane().add(btn5);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
}
}

7.8.6 Pengaturan dengan GridBagLayout

GridBagLayout merupakan kelas yang dapat digunakan untuk meletakkan komponen secara bebas. Hal
ini berbeda dengan GridLayout. Jika menggunakan GridBagLayout, setiap komponen dapat menempati
ukuran yang berbeda dengan yang lain, setiap komponen dapat menempati lebih dari satu grid.

Gambar 7-7 GridBagLayout

Source Codenya :
import javax.swing.*;
import java.awt.*;
public class GridBagLayoutDemo {
public static void main(String[] args) {
JFrame frame = new JFrame ("GridBagLayoutDemo");
GridBagLayout layout = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
frame.getContentPane().setLayout(layout);
c.fill = GridBagConstraints.HORIZONTAL;
JButton btn1 = new JButton("Button 1");
c.weightx = 0.5;
c.gridx = 0; //kolom 0
c.gridy = 0; //baris 0
layout.setConstraints(btn1,c);
frame.getContentPane().add(btn1);
JButton btn2 = new JButton("Button 2");
c.gridx = 1; //kolom 1
c.gridy = 0; //baris 0
layout.setConstraints(btn2,c);
frame.getContentPane().add(btn2);
JButton btn3 = new JButton("Long-Named Button 3");
c.ipady = 30;//perbesar tinggi
c.gridwidth = 2; //menempati 2 kolom
c.gridx = 0; //kolom 0
c.gridy = 1; //baris 1

Modul Praktikum PBO 72

 layout.setConstraints(btn3,c);
frame.getContentPane().add(btn3);
JButton btn4 = new JButton("Button 4");
c.ipady = 50;//perbesar tinggi
c.gridwidth = 1; //menempati 1 kolom
c.gridx = 0; //kolom 0
c.gridy = 2; //baris 2
layout.setConstraints(btn4,c);
frame.getContentPane().add(btn4);
JButton btn5 = new JButton("Button 5");
c.ipady = 0; //tinggi normal
c.gridwidth = 1; //menempati 1 kolom
c.gridx = 1; //kolom 1
c.gridy = 2; //baris 2
c.insets = new Insets(10,0,0,0); //t,l,b,r
c.anchor = GridBagConstraints.SOUTH;
layout.setConstraints(btn5,c);
frame.getContentPane().add(btn5);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
}
}

7.8.7 Pengaturan dengan GroupLayout

GroupLayout menggunakan dua tipe penyusunan, yaitu sequential dan parallel.
1. Penyusunan secara sequential sangatlah sederhana, yaitu menempatkan komponen-komponen
dengan berurutan setelah komponen pertama diletakan, mirip dengan BoxLayout atau FlowLayout
yang menempatkan komponen-komponen berikutnya dalam satu line yang sama.
2. Dalam penyusunan secara parallel, komponen dapat ditaruh sebagai baseline-, top-, atau bottom-
jika mengukuti sumbu vertikal. Komponen juga ditaruh sebagai left-, right- atau center- jika
mengukuti sumbu horizontal.
Contoh Ilustrasi: Terdapat tiga buah komponen C1, C2, C3. Komponen-komponen berikut
akan disusun dengan cara sequential groupdan parallel group.
Sequential:

Gambar 7-8 Susunan GrupLayout Sequential

Parallel:

Gambar 7-9 Susunan GrupLayout Paralel

Modul Praktikum PBO 73

 Gambar 7-10 Contoh tampilan field find
Pembahasannya:
Horizontal Layout

Gambar 7-11Contoh layout horisontal dan berurutan

Kelompokkan komponen-komponen diatas menjadi beberapa grup yang tersusun secara berurutan dan
horizontal. Maka dari kelompok-kelompok tersebut dapat dibuat code awal sebagai berikut.
layout.setHorizontalGroup ( layout.createSequentialGroup()
.addComponent(label)
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING))
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING))
);

Gambar 7-12 Detail pembagian pada GrupLayout

Kemudian grup yang ada, di bagi-bagi kembali. Maka code akan berkembang menjadi,
layout.setHorizontalGroup(layout.createSequentialGroup()
.addComponent(label)
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(textField)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(caseCheckBox)
.addComponent(wholeCheckBox))

.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(wrapCheckBox)
.addComponent(backCheckBox))))
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING))
);
Setelah itu grup terakhir yang berisi dua buah button, tambahkan pada code. Maka code akan
berkembang menjadi,

Modul Praktikum PBO 74

layout.setHorizontalGroup(layout.createSequentialGroup()
.addComponent(label)
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(textField)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(caseCheckBox)
.addComponent(wholeCheckBox))

.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
.addComponent(wrapCheckBox)
.addComponent(backCheckBox))))
.addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING))
.addComponent(findButton)
.addComponent(cancelButton))
);

7.8.8 Pengaturan dengan SpringLayout

SpringLayout mulai ada di JDK pada versi 1.4, yaitu untuk mendukung layout pada GUI. SpringLayout
merupakan layout manager yang sangat flexibel, dimana ukuran layout dapat berubah-ubah sesuai
dengan banyak komponen.

7.9 Event Handling

Untuk mendeteksi atas apa yang dilakukan oleh user, diperlukan penanganan khusus terhadap event
(peristiwa yang di-stimulasikan/di-trigger) yang diperlukan oleh user terhadap komponen GUI tertentu.
Penanganan ini disebut Event Handling Component. Event Handling Component dibagi atas 2 bagian,
yaitu Event Listener dan Event Handler. Untuk mengenal 2 Method Event tersebut dapat diilustrasikan
sbb:
Bila mengklik suatu object button, maka tercipta event. Event ini ditangkap oleh Event Listener dan
secara otomatis akan diberi ID (identitas) seperti button1, button2, textfield1, dll atau kita dapat
memberikan ID atas komponen tersebut dengan memberi nama suatu object. Sehingga java mengenal
event mana yang ditangkap.
Selanjutnya, tentukan Event Handler dari komponen tersebut, berupa blok program/statement yang
memproses bila terjadi suatu event yang ditangkap oleh Event Listener. Event Handler dapat
dianalogian seperti fungsi operasi +, -, :, x, = pada kalkulator. Jika ingin mengalikan 2 bilangan maka
harus menekan tombol ’x’. Setiap tombol operasi akan mengasilkan pemrosesan yang berbeda-beda.
Contoh Program:

Gambar 7-13 Contoh tampilan program dengan event handler

Source Codenya:

Modul Praktikum PBO 75

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class event_handling{
private JButton b1,b2,b3,b4;
private JTextField text1,text2;
//private JPanel panel1,panel2;
private JLabel label1,label2;
private JFrame frame;
private int a,b;
public event_handling()
{
frame = new JFrame("EventHandler Demo");
text1 = new JTextField(10);
text2 = new JTextField(10);
b1 = new JButton("tambah");
b2 = new JButton("kurang");
b3 = new JButton("kali");
b4 = new JButton("bagi");
label1 = new JLabel("Bilangan 1 :");
label2 = new JLabel("Bilangan 2 :");
}
public void launch()
{
FlowLayout layout = new FlowLayout(FlowLayout.CENTER);
frame.getContentPane().setLayout(layout);
//frame.setLayout(new FlowLayout(FlowLayout.CENTER));
b1.addActionListener(new tambahHandler());
b2.addActionListener(new kurangHandler());
b3.addActionListener(new kaliHandler());
b4.addActionListener(new bagiHandler());
JPanel panel1 = new JPanel();
JPanel panel2 = new JPanel();
panel1.add(label1);
panel1.add(text1);
panel1.add(label2);
panel1.add(text2);
panel2.add(b1);
panel2.add(b2);
panel2.add(b3);
panel2.add(b4);
frame.getContentPane().add(panel1);
frame.getContentPane().add(panel2);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400,200);
frame.show();
}
private void getText()
{
a = Integer.parseInt(text1.getText());

Modul Praktikum PBO 76

 b = Integer.parseInt(text2.getText());
}
private class tambahHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
getText();
int c = a + b;
JOptionPane.showConfirmDialog(null,"Hasil Penjumlahan adalah:
"+c,"Result",JOptionPane.OK_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
}
private class kurangHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
getText();
int c = a - b;
JOptionPane.showConfirmDialog(null,"Hasil Pengurangan adalah:
"+c,"Result",JOptionPane.OK_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
}
private class kaliHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
getText();
double c = a * b;
JOptionPane.showConfirmDialog(null,"Hasil Perkalian adalah:
"+c,"Result",JOptionPane.OK_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
}
private class bagiHandler implements ActionListener {
public void actionPerformed(ActionEvent e) {
getText();
double c = a / b;
JOptionPane.showConfirmDialog(null,"Hasil Pembagian adalah:
"+c,"Result",JOptionPane.OK_OPTION,JOptionPane.INFORMATION_MESSAGE);
}
}
public static void main(String[] args) {
event_handling gui = new event_handling();
gui.launch();
}
}

Modul Praktikum PBO 77

 Modul 8 : JDBC

8.1 Tujuan
Setelah mengikuti praktikum ini mahasiswa diharapkan dapat :
1. Memahami dan mengimplementasikan cara membuat desain interface dengan menggunakan
netbeans.
2. Memahami dan mengimplementasikan Applet pada suatu program java.
3. Memahami konsep JDBC
4. Mengimplementasikan JDBC ke dalam suatu program java

8.2 Pendahuluan
Sebelum ke JDBC kita implementasikan dulu modul sebelumnya yaitu membuat proyek dan GUI dengan
Netbeans. Dalam netbeans, semua perancangan dan pemrograman dilakukan di dalam kerangka sebuah
proyek. Proyek netbeans merupakan sekumpulan file yang dikelompokkan di dalam suatu kesatuan.
• Membuat proyek
Sebelum membuat program java dengan netbeans, langkah pertama adalah membuat proyek.
1 Jalankan menu File → Project (Ctrl+Shift+N) untuk membuka suatu dialog New Project.

Gambar 8-1 Contoh tampilan program dengan event handler

2 Dalam dialog, pilih Categories : General dan Projects : Java Application. Lalu klik tombol next.
3 Pilih dahulu lokasi project dengan menekan tombol browse. Akan tampil direktori dan kita
dapat memilih di direktori mana project disimpan. Setelah memilih, klik open.
4 Kembali ke dialog new project, isikan project name. Misalnya disini project name : Modul7.
Perhatikan bahwa project folder secara otomatis akan diset sesuai dengan nama project.
5 Centang pada Set as Main Project dan pada Create Main Class. Terakhir klik tombol finish.
Di dalam netbeans akan dibuka secara otomatis file utama java bernama main.java yang berada
pada package modul7

Modul Praktikum PBO 78

• Contoh Pembuatan interface dengan Netbeans
Akan dibuat suatu aplikasi sederhana yaitu aplikasi penjualan barang dimana data inputan akan
disimpan pada object barang. Langkah-langkah:
1 Buat dahulu new project seperti yang sudah dijelaskan sebelumnya.(asumsi sudah dibuat).
2 Buat sebuah package dengan nama gui dengan: klik File → New File → Java → Java Package.
Pengelempokan suatu kelas dalam package dapat memudahkan mengatur source code.
3 Klik kanan pada package gui, pilih New → JFrame Form. Beri nama FormPenjualan. Klik Finish.
4 Maka akan terbuka suatu File FormPenjualan.java. Disinilah kita akan membuat desain interface.
5 Pada sebelah kanan aplikasi terdapat Palette, terdiri dari komponen seperti JTextField, Jbutton,
dsb, yang dapat digunakan dengan cara di drag and drop pada kontainer yang sudah dibuat,
dalam hal ini JFrame. Pilih dan atur komponen-komponen tersebut seperti gambar di bawah

Gambar 8-2 Tampilan Netbeans

6 Tiap komponen memiliki properties. Klik kanan pada komponen, lalu klik properties untuk
melihat properties dari suatu komponen

Gambar 8-3 Tampilan JTextField properties

Modul Praktikum PBO 79

 7 Untuk mengubah nama variabel suatu komponen, pada jendela inspector, klik kanan suatu komponen
lalu pilih change variable name, maka akan keluar dialog yang meminta nama baru. Masukan nama
variabel yang baru lalu klik OK
8 Beri nama masing-masing JTextField sesuai dengan label yang ada disampingnya, yaitu txtkode, txtnama,
dan txtharga. Serta ubah nama JButton menjadi simpan dan JTextArea menjadi output.
9 Sekarang kita akan membuat action dari tombol simpan. Namun terlebih dahulu harus membuat kelas
Barang untuk menyimpan data input. Buat sebuah package baru dengan nama data pada folder Source
Packages. Kemudian buat Java Kelas pada package data dengan nama Barang.
10 Pada file Barang.java, masukan kode untuk menerima input dari kelas FormPenjualan. Kode programnya
adalah sebagai berikut :
package data;
public class Barang {
private String kode;
private String nama;
private int harga;
public Barang(){
}
public String getKode() {
return kode;
}
public void setKode(String kode) {
this.kode = kode;
}
public String getNama() {
return nama;
}
public void setNama(String nama) {
this.nama = nama;
}
public int getHarga() {
return harga;
}
public void setHarga(int harga) {
this.harga = harga;
}
}

11 Untuk compile dengan shortcut F9 sedangkan untuk running program dengan Shift+F6. Compile
file Barang.java.
12 Kembali ke FormPenjualan.java. Kita akan membuat suatu Listener untuk event yang terjadi.
Dalam hal ini, akan dibuat action listener dari tombol simpan. Klik kanan di tombol simpan |
pilih Events | Action | actionPerformed.
13 Setelah itu tuliskan kode pada method simpanActionPerformed yang akan dieksekusi setiap kali
tombol simpan ditekan. Sebelumnya import terlebih dahulu package data dengan cara
menuliskan import data.Barang setelah kode package gui agar kelas barang dikenali di kelas
FormPenjualan.
14 Tuliskan kode program seperti dibawah:
private void simpanActionPerformed(java.awt.event.ActionEvent evt) {
Barang brg=new Barang();
brg.setKode(txtkode.getText());
brg.setNama(txtnama.getText());
brg.setHarga(Integer.parseInt(txtharga.getText()));

Modul Praktikum PBO 80

 txtkode.setText("");
txtnama.setText("");
txtharga.setText("");
output.setText("Kode : "+brg.getKode()
+"\nNama : "+brg.getNama()
+"\nHarga : "+brg.getHarga());
}

15 Kemudian pada kelas Main atau file Main.java, tambahkan kode seperti berikut
package modul7;
import gui.FormPenjualan;
public class Main {
public static void main(String[] args) {
FormPenjualan form= new FormPenjualan();
form.setVisible(true);
}
}

16 Klik Run Build Main Project (F11) atau Clean and Build Main Project (Shift+F11) untuk
mendeploy source code menjadi executable file dalam hal ini, file modul7.jar yang terdapat
pada folder dist di project folder yang sudah kita buat.
17 Berikut adalah hasil dari aplikasi sederhana yang sudah kita buat:

Gambar 8-4 Tampilan aplikasi penjualan barang

8.3 JDBC (Java Database Connectivity)

Java juga menyediakan fungsi untuk menghubungkan suatu aplikasi yang dibangun dengan
menggunakan bahasa pemrograman java. Untuk menghubungkannya dengan menggunakan JDBC.
Dengan JDBC, programmer dapat menggunakan SQL statement untuk membentuk, memanipulasi atau
memelihara suatu data. Dibawah ini adalah cara untuk menghubungkan java dengan database
microsoft access, oracle dan mysql.
Java Database Connectivity adalah versi ODBC yang dibuat oleh Sun Microsystem. Cara kerjanya mirip
tapi JDBC sepenuhnya dibangun dengan java API sehingga ia dapat dipakai cross platform sedangkan
ODBC dibangun dengan bahasa C sehingga ia hanya dapat dibangun pada platform spesifik.Seperti
ODBC, JDBC didasarkan pada X/Open SQL Level Interface (CLI).

Modul Praktikum PBO 81

Dengan JDBC API, kita dapat mengakses database dari vendor-vendor ternama seperti Oracle, Sybase,
Informix, Interbase. Untuk itu, diperlukan driver yang akan dipakai untuk mengakses database di server
dari dalam program kita (client). Setiap server dari vendor berbeda memiliki driver yang berbeda.
Driver ini dapat kita download dari situs http://java.sun.com/products/jdbc atau download dari situs
vendor yang bersangkutan.
Dengan JDBC, kita dapat melakukan mengirimkan perintah-perintah SQL ke RDBMS. Kelas-kelas serta
interface JDBC API dapat diakses dalam paket java, sql(core API) atau javax.sql(Standard Extension API).
Secara umum langkah-langkah untuk menghubungkan Java dengan database, yaitu

8.3.1 Inisialisasi Driver

Class.forName( “nama_driver” );
Untuk nama_driver berbeda-beda tiap database yang digunakan :
• Untuk microsoft access yaitu sun.jdbc.odbc.jdbcOdbcDriver.
• Untuk oracle yaitu oracle.jdbc.driver.OracleDriver.
• Untuk mysql yaitu org.gjt.mm.mysql.Driver.
Catatan :
Pada Netbeans 6.5, sudah terdapat beberapa driver yang dapat digunakan langsung seperti Java DB,
MySQL, dan PostgreSQL. Cara penggunaannya yaitu dengan mengklik kanan pada folder library dalam
project yang dibuat kemudian pilih Add Library.., lalu pilih driver yang akan kita pakai.
8.3.2 Koneksi Ke Database dengan menggunakan URL
Connectionvar_koneksi=
DriverManager.getConnection(“nama_URL”,”nama_user”,”password”);
Tiap database mempunyai nama_URL yang berbeda-beda yaitu :
• Pada access → jdbc:odbc:nama_database
• Pada Oracle → jdbc:oracle:thin:localhost:1521:ORCL
• Pada mysql → jdbc:mysql://localhost/nama_database
8.3.3 Penggunaan Database
Statement
Statement merupakan suatu kelas pada java yang digunakan untuk mengeksekusi suatu query,
digunakan setelah inisialisasi variable koneksi pada Connection dipoint ke-2. Inisialisasinya:
misalkan : variabel koneksinya yaitu conn , maka
Statementvar_statement = conn.createStatement();
DriverManager.getConnection(“nama_URL”,”nama_user”,”password”);
Untuk mengakhiri suatu transaksi dengan menggunakan query dengan cara menutup variable
statement yang sudah diinisialisasi.
misal : variable statementnya yaitu stmnt, maka
stmnt.close();
DriverManager.getConnection(“nama_URL”,”nama_user”,”password”);

ResultSet
Setelah menginisialisai variabel statement maka selanjutnya menginisialisai variabel ResultSet yang
nantinya akan digunakan untuk menyimpan suatu baris record pada database, dengan kata lain
variabel ini merupakan pointer yang akan menunjuk suatu baris pada table. Caranya yaitu :

Modul Praktikum PBO 82

ResultSet var_set;
DriverManager.getConnection(“nama_URL”,”nama_user”,”password”);

8.3.4 Mengakhiri Koneksi

Untuk menjaga keamanan data maka perlu mengakhiri koneksinya dengan cara (misal variabel
koneksinya conn):
conn.close();
DriverManager.getConnection(“nama_URL”,”nama_user”,”password”);

Berikut adalah contoh penggunaan JDBC dengan menggunakan MySQL sebagai databasenya dimana
username root dan password tidak diset serta berjalan di localhost. Disini kita akan membuat aplikasi
penjualan sederhana yang merupakan pengembangan dari aplikasi yang sudah kita buat diatas.
Pertama kita buat database dengan nama db_penjualan, dengan strutur tabel seperti dibawah:
CREATEDATABASEdb_penjualan
CREATE TABLE tabel_penjualan(
kode varchar(20),nama varchar(20),harga int
);
Selanjutnya, pada project yang sudah kita buat sebelumnya yaitu Project Modul7, lakukan sedikit
perubahan pada kelas FormPenjualan dimana button simpan dan textarea output dihapus dari panel
dan tambahkan dua button baru dengan label dan nama variabel insert dan view, serta tambahkan
satu komponen JTable dengan nama variabel output. Gambar dibawah adalah kelas FormPenjualan
setelah diedit.

Gambar 8-5 Tampilan saat mengedit kelas FormPenjualan

Klik kanan JTable dan pilih Table Contents. Pilih tab Colums dan ubah count menjadi 3. Ubah Title 1,
Title 2, dan Title 3 menjadi Kode, Nama, dan Harga. Lalu, pilih tab Rows dan ubah count menjadi 20,
kemudian itu klik Close.
Setelah kelas FormPenjualan diedit, tambahkan driver MySQL dengan cara klik kanan pada folder
library, pilih Add Library, lalu pilih MySQL JDBC Driver kemudian klik add library.

Modul Praktikum PBO 83

 Gambar 8-6 Menambahkan driver MySQL

Selanjutnya buat kelas baru pada package data dengan nama kelas Database. Di bawah ini adalah
kodenya:
package data;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.swing.JOptionPane;

public class Database {

private String dbuser = "root";
private String dbpasswd = "";
private Statement stmt = null;
private Connection con = null;
private ResultSet rs = null;

public Database(){
//Loads JDBC driver
try {
Class.forName("org.gjt.mm.mysql.Driver");
}catch(Exception e) {
JOptionPane.showMessageDialog(null,""+e.getMessage(),"JDBC
Driver Error",JOptionPane.WARNING_MESSAGE);
}
try {
con = DriverManager.getConnection("jdbc:mysql://localhost/
db_penjualan",dbuser, dbpasswd);
stmt = con.createStatement();
}catch (Exception e) {
JOptionPane.showMessageDialog(null,""+e.getMessage(),"Connection
Error",JOptionPane.WARNING_MESSAGE);
}
}
public ResultSet getData(String SQLString){
try {

Modul Praktikum PBO 84

 rs = stmt.executeQuery(SQLString);
}catch (Exception e) {
JOptionPane.showMessageDialog(null,"Error :"
+e.getMessage(),"Communication
Error",JOptionPane.WARNING_MESSAGE);
}
return rs;
}
public void query(String SQLString) {
try {
stmt.executeUpdate(SQLString);
}catch (Exception e) {
JOptionPane.showMessageDialog(null,"error:"+
e.getMessage(),"Communication
Error",JOptionPane.WARNING_MESSAGE);
}
}
}

Setelah membuat kelas Database, selanjutnya edit kelas barang dengan menambahkan 2 method baru,
yaitu saveBarang dan getBarang. Berikut adalah potongan kode pada kelas Barang.
package data;
import java.sql.ResultSet;

public class Barang {

private String kode;
private String nama;
private int harga;

public Barang(){ }
public String getKode(){
return kode;
}
public void setKode(String kode) {
this.kode = kode;
}
public String getNama(){
return nama;
}
public void setNama(String nama){
this.nama = nama;
}
public int getHarga(){
return harga;
}
public void setHarga(int harga){
this.harga = harga;
}

//method tambahan
public void saveBarang(){
Database db=new Database();
String s="insert into tabel_penjualanvalues
('"+this.kode+"','"+this.nama+"',"+this.harga+")";
db.query(s);

Modul Praktikum PBO 85

 }
public ResultSet getBarang(){
ResultSet result=null;
Database db=new Database();
String s="insert into tabel_penjualanvalues
('"+this.kode+"','"+this.nama+"',"+this.harga+")";
db.query(s);
return result;
}
}

Setelah kelas Database dibuat dan kelas Barang diedit, selanjutnya perlu ditambahkan action listener
pada button yang ada di kelas FormPenjualan untuk menangkap event yang terjadi, dalam hal ini
JButton insert dan view. Button insert berfungsi untuk memasukan data yang ada di textfield kode,
nama, dan harga ke dalam tabel tabel_penjualan yang ada di database db_penjualan, sementara view
untuk menampilkan data ke dalam JTable output. Di bawah ini adalah kode action listener untuk
button insert dan view. Namun sebelumnya import terlebih dahulu kelas Database dan ResultSet ke
dalam kelas FormPenjualan dengan cara import data.Database; dan import java.sql.ResultSet;
Berikut adalah kode action listener untuk button insert dan view.
private void insertActionPerformed(java.awt.event.ActionEvent evt) {
Barang brg=new Barang();
brg.setKode(txtkode.getText());
brg.setNama(txtnama.getText());
brg.setHarga(Integer.parseInt(txtharga.getText()));
brg.saveBarang();
javax.swing.JOptionPane.showMessageDialog(null,
"Insert Berhasil");
txtkode.setText("");
txtnama.setText("");
txtharga.setText("");
}

private void viewActionPerformed(java.awt.event.ActionEvent evt) {

Database db=new Database();
int i=0;
ResultSet rs=null;
try{
rs=db.getData("select * from tabel_penjualan");
while(rs.next()){
output.setValueAt(rs.getString("kode"), i, 0);
output.setValueAt(rs.getString("nama"), i, 1);
output.setValueAt(rs.getInt("harga"), i, 2);
i++;
}
rs.close();
}
catch(Exception e){
javax.swing.JOptionPane.showMessageDialog(null,"Error:"+
e.getMessage());
}
}

Modul Praktikum PBO 86

Selanjutnya lakukan deploy aplikasi ini dengan mengklik Run → Clean and Build Project atau tekan Shift
+ F11. Aplikasi dapat dijalankan dengan mengeksekusi file Modul7.jar yang ada di folder dist pada
project folder yang kita buat. Namun sebelumnya jalankan terlebih dahulu server MySQL nya.

Gambar 8-7 Tampilan Insert Barang

Gambar 8-8 Tampilan view barang

Modul Praktikum PBO 87

 Buku Pendukung

[1] Anonim. 2012. Modul Praktikum Pemrograman Berorientasi Objek. Fakultas

Informatika. Institut Teknologi Telkom, Bandung.

[2] Barclay, K. & J.Savage.2004.Object-Oriented Design with UML and Java.

Massachusetts:Elsevier Butterworth-Heinemann.

[3] Bruegge , Bernd & Allen H. Dutoit .2010. Object-Oriented Software Engineering Using
UML, Patterns, and Java™ Third Edition.Pennsylvania: Prentice Hall.

[4] Deitel, H.M & Deitel,P.J. 2004. Java How to Program Sixth Edition. New Jersey:
Prentice Hall.

[5] Sierra, Kathy & Bates, Bert. 2005. Head First Java, 2nd Edition. Sebastopol: O'Reilly
Media.

[6] Sierra, Kathy & Bates, Bert. 2008. SCJP Sun Certified Programmer for Java™ 6 Study
Guide. New York: McGraw-Hill.

Modul Praktikum PBO 88

Modul Praktikum PBO 89