MODUL

Pemrograman Berorientasi Objek III

Ahmad Zuhri, S.Kom

AMIK TRI-DHARMA PALU

1
 DAFTAR ISI

Sampul................................................................................................................... i
Daftar Isi............................................................................................................ii
Bagian I Membuat Aplikasi Kalkulator.............................................................1
1. Desain Form............................................................................................. 1
2. Pengkodean.............................................................................................. 6
3. Memberi Fungsi Tombol..........................................................................11
4. Menambahkan Look and Feel..................................................................17

Bagian II Koneksi Ke Database MySql.................................................................23

1. Instal xampp.............................................................................................23
2. Membuat database................................................................................23
3. Membuat Project......................................................................................24
4. Pengkodean..............................................................................................27

Bagian III Membuat Laporan dengan iReport.......................................................34

1. Membuat Koneksi....................................................................................34
2. Desai Laporan...........................................................................................35

2
 BAGIAN I
MEMBUAT APLIKASI KALKULATOR

Pada langkah ini anda diharapkan dapat membuat aplikasi menggunakan pemrograman Java.
Konsep-konsep Java yang telah dibahas mulai dari langkah 1 sampai 4 akan diterapkan dalam
membuat aplikasi pada langkah ke 5 ini.

Java merupakan bahasa pemrograman yang mampu membuat 3 kategori aplikasi, yaitu aplikasi
berbasis dekstop, web dan mobile. Dari ketiga kategori tersebut, aplikasi yang akan diambil
sebagai contoh adalah aplikasi berbasis dekstop yaitu program kalkulator. Aplikasi web dan
mobile akan saya bahas pada buku selanjutnya.
Aplikasi kalkulator yang akan dibuat pada langkah ini terdiri dari 2 class yaitu FormKalkulator
dan Rumus. Kedua class tersebut berada dalam paket yang berbeda. Class FormKalkulator
berada dalam paket form dan Rumus berada dalam paket fungsi. Berikut gambarnya :
form fungsi

FormKalkulato Rumus

Gambar 5.1 Hirarki Kasus

Pembahasan membuat kalkulator ini dibagi menjadi 2 bagian yaitu tahap mendesain dan tahap
pengkodean. Kedua tahap itu akan dibahas secara terpisah pada bagian selanjutnya.

Desain Form
Program kalkulator yang akan di buat pada pembahasan ini didesain dalam class
FormKalkulator. Untuk membuat form ini, silahkan anda ikuti langkah-langkah berikut :

1. Buatlah paket form yang nantinya berfungsi sebagai tempat untuk Frame
FormKalkulator. Cara pembuatan paket sudah kita bahas sebelumnya.
2. Buatlah Frame baru dengan nama FormKalkulator. Caranya adalah klik kanan pada paket

Gambar 5.2 Langkah membuat Form

3
 Kotak yang muncul merupakan form pengisian nama JFrame. Berikut tampilannya.

Gambar 5.3 Pemberian nama Form

Form ini sebenarnya merupakan sebuah class. Dengan memilih JFrame Form, class ini secara
otomatis menjadi class turunan dari class JFrame sehingga mewariskan frame pada class ini.
Hasil setelah anda pilih Finish adalah sebagai berikut :

Gambar 5.3 Pemberian nama Form

3. Editlah keterangan Frame dengan mengklik kanan di atas [JFrame] yang berada pada bagian
Inspector ( bagian kiri bawah NetBeans ) , pilih properties.
Yang akan dirubah disini adalah title dan resizable. Editlah title dengan nama “Kalkulator
Cerdas”. Berikut gambarnya :

Gambar 5.4 Pemberian title Form

Sedangkan untuk resizable, hilangkanlan centang pada properties ini seperti gambar berikut :

4
 Gambar 5.5 Pilihan resizable

Cobalah anda jalankan class FormKalkulator dengan mengklik kanan pada class,
kemudian pilih Run. Hasil dari perubahan yang dilakukan tadi akan muncul titel di bagian
atas Frame dan Frame tidak bisa dirubah ukurannya. Berikut gambarnya :

Gambar 5.6 Tampilan Form

4. Langkah selajutnya adalah mengisi komponen-komponen kalkulator ke dalam Frame.

Komponen ini diambil dari Palette ( terletak di bagian kanan NetBeans ). Jika palette ini belum
tampil dalam NetBeans Anda, palette dapat dimunculkan melalui menu Window  Palette.
Berikut tampilannya :

Gambar 5.7 Tampilan Palette

5. Komponen pertama yang ditambahkan ke dalam frame adalah Panel. Panel berfungsi sebagai
wadah komponen-komponen lain. Kelebihan lain dari Jpanel adalah dapat diberikan bermacam-
macam warna. Tariklah Panel dari bagian Palette dan kemudian letakkan di atas Frame.

6. Selanjutnya, rubahlah warna Panel tersebut menjadi warna putih. Cara merubah warna ini
dilakukan dengan mengklik kanan pada panel, kemudian pilih Proerties  rubah warna
background dengan warna putih. Berikut tampilannya :

5
 Gambar 5.8 Pilihan warna background Panel

7. Tambahkan kembali Panel di atas Panel pertama tadi dengan ukuran yang lebih kecil
sehingga tampilannya seperti gambar berikut ini :

Gambar 5.9 Tampilan Panel Kalkulator

8. Rubahlah jenis border Panel yang kedua pada kotak properties, pilih jenis Bevel Border
dengan type Rised seperti pada gambar berikut ini :

Gambar 5.9 Pilihan jenis border

Hasil Panel setelah merubah bordernya akan tampak timbul seperti gambar berikut :

6
 Gambar 5.11 Tampilan border Panel

9. Selanjutnya adalah menambahkan komponen TextFile dari Palette yang berfungsi sebagai
layar kalkulator. Hilangkan tulisannya dengan mengklik kanan, kemudian pilih Edit Text.
Kemudian rubahlah nama TextFile dengan layar dari menu Change Variable Name.
Berikut gambar pilihannya setelah diklik kanan pada TextFile :

Gambar 5.12 Pilihan untuk TextFile

Selanjutnya, rubahlah pengaturan TextFile lainnya dari Properties seperti berikut :
- font = Thoma 14 Bold Italic
- foreground = Biru
- horizontal aligment = RIGHT

10. Layar untuk menampilkan angka selesai, selanjutnya adalah tombo-tombolnya. Dari jendela
Palette, tariklah komponen Button untuk tombol kalkulator. Rubahlah label tombol sesuai
dengan fungsinya serta rubahlah warna dan font seperti gambar berikut :

7
 Gambar 5.13 Design Kalkulator

11. Terakhir dalam desain ini adalah merubah nama masing-masing tombol sama seperti
TextFile dengan nama layar. Perubahan nama komponen akan memudahkan dalam
mengingat dan mengimplementasikan komponen tersebut. Berilah nama masing-masing
tombol sesuai dengan daftar berikut :

- = tombol0 - = tombolKali

- = tombol1 - = tombolBagi

- = tombol2 - = tombolTambah

- = tombol3 - = tombolKurang

- = tombol4 - = tombolKoma

- = tombol5 - = tombolPlusMinus

- = tombol6 - = tombolDel

- = tombol7 - = tombolC

- = tombol8 - = tombolSamaDengan

- = tombol9
-

Pengkodean
Pengenalan kode class FormKalkulator
FormKalkulator yang sudah didesain pada bagian sebelumnya akan mengenerate kode
pembentuknya. Untuk melihat kodenya, cobalah anda pilih tampilan Source. Sedangkan untuk
melihat tampilan aplikasi dapat dilah kembali dengan memilih tampilan Design. Berikut gambar
pilihan yang dimaksud:

8
 Gambar 5.14 Pilihan Source dan Design Form
Kembali pada kode class FormKalkulator. Setelah mendesain tampilan kalkulator, NetBeans akan
mengenerate kode yang bisa anda lihat pada tampilan Source. Kode tersebut terdiri dari method,
konstruktor, variabel yang susunannya sesuai dengan gambar berikut:

Gambar 5.15 Urutan isi class FormKalkulator

Cobalah anda perhatikan kode pendeklarasian class FormKalkulator. Terdapa kode tambahan
extends javax.swing.JFrame{ yang membuat kode ini menjadi class turunan, yaitu turunan
dari JFrame. Inilah alasan mengapa class FormKalkulator dapat ditambahkan tombol dan lain
sebagainya. Sifat tersebut merupakan sifat yang diwarisi dari JFrame.

Kode selanjutnya setelah pendeklarasian class FormKalkulator adalah kostruktor

FormKalkulator ( nama konstruktor sama dengan nama class ). Berikut kodenya :

public FormKalkulator() {
initComponents();
}

Dalam isi konstruktor terdapat kode pemanggilan method initComponents(). Isi method ini
merupakan hasil generate NetBeans ketika mendesain komponen-komponen kalkulator. Semua
kode perubahan yang dilakukan pada komponen kalkulator baik berupa warna, jenis huruf, ukuran
atau letak komponen tersimpan pada method initComponents(). Cobalah anda klik tanda
maximize (+) yang ada di depan Generated Code seperti pada gambar berikut :

9
 Gambar 5.16 Kode Generate oleh NetBeans

Setelah anda klik, maka akan tampil semua kode hasil desain tampilan kalkulator yang telah
dibuat. Untuk menyembunyikan kembali cukup dengan mengkilik tanda minimize (-) yang
merupakan perubahan maximize tadi.

Selanjutnya setelah method initComponent(), terdapat method main(). Method inilah yang
pertama dipanggil atau dieksekusi ketika class FormKalkulator dijalankan. Berikut kodenya :

public static void main(String args[])

{ java.awt.EventQueue.invokeLater(new Runnable()
{
public void run() {
new FormKalkulator().setVisible(true);
}
});
}

Kode new FormKalkulator().setVisible(true); merupakan kode dari method main() yang

membuat objek baru dengan memanggil konstruktor FormKalkulator().
Bagian terakhir dari class ini adalah kumpulan komponen kalkulator yang meliputi tompol, layar
dan panel dideklarasikan sebagai variabel. Variabel inilah yang diakses oleh method
initComponent().

Pembahasan ini class FormKalkulator di atas dapat dimpulkan urutan pengeksekusiannya sebagai
berikut :

1. Ketika class FormKalkulator dijalankan, maka yang dicari dan dieksekusi pertama kali
adalah method main().
2. Dari dalam method main(), konstruktor FormKalkulator() dieksekusi.
3. Selanjutnya, konstruktor FormKalkulator() memanggil method initComponent().
4. Dari dalam method initComponent() komponen-komponen kalkulator seperti tombol,
layar dan panel dijalankan sehingga kompone tersebut tampil di atas frame.

Membuat Class Rumus

Class Rumus dalam aplikasi kalkulator ini memiliki peran yang sangat penting. Hal ini dikarenakan
class Rumus memiliki method-method yang akan memproses pengolahan angka untuk kalkulator.
Pengolahan tersebut meliputi perkalian ( * ), pembagian ( / ), penjumlahan ( + ) dan pengurangan ( -
). Class ini berada dalam paket fungsi. Sebenarnya class ini dapat disatukan dengan
FormKalkulator dalam paket form. Ataukah method-method pada Rumus dapat langsung
disatukan dalam FormKalkulator sehingga class sehingga Rumus tidak perlu dibuat. Alasannya
adalah saya ingin menunjukkan konsep pemrograman berorientasi objek dimana class yang berbeda
dapat saling berhubungan.

10
Class Rumus memiliki empat method yang bertujuan untuk menyelesaikan pengolahan angka,
berikut urutan method dalam class Rumus :

Gambar 5.15 Urutan isi class Rumus

Sebenarnya urutan-urutan pendeklarasian method di atas tidak harus berurutan. Method tetap
dapat berfungsi meskipun urutannya berubah. Fungsi masing-masing method yang dimaksud
adalah :

1. Method keDouble( String angkaString ) berfungsi merubah angka yang bertipe

String ( nilai dari angkaString ) menjadi angka bertipe double. Hal ini dilakukan karena
angka yang tampil di layar kalkulator memiliki tipe String. Agar angka yang tersebut dapat
dihitung, maka terlebih dahulu dikonversi menjadi data bertipe double. Kode yang melakukan
konversi adalah dalam method ini adalah :

Double.parseDouble(angkaString);.

2. Method keString( double angkaDouble ) merupakan kebalikan dari method

keDouble(). Method ini berfungsi mengkonversi data double ke data String. Hal ini dilakukan
untuk mengembalikan hasil pengolahan angka agar dapat ditampilkan kembali pada layar. Kode
yang melakukan konversi ini adalah

Double.toString(angkaDouble);.

3. Method bulatkan( double angkaDouble ) berfungsi membulatkan angka yang akan

ditampilkan dilayar. Misalnya hasil perhitungan adalah 6.0, maka angka 0 akan dihilangkan
sebelum ditampilkan di layar menjadi 6 saja. Fungsi ini sebenarnya untuk menyederhanakan
hasil pada kalkulator. Berikut kodenya :

String hasil=keString(angkaDouble);
int indexKoma = hasil.indexOf('.');
if(hasil.subString(indexKoma+1).equals("0")){
hasil = hasil.subString(0,indexKoma);
}
return hasil;

Urutan proses yang terjadi dalam method ini adalah dengan merubah terlebih dahulu angka ke
dalam bentuk String. Selanjutnya method mencari nilai index koma dengan kode
hasil.indexOf('.'). berdasarkan nilai index ini, method melakukan pengujian apakah angka
dibelakang koma hanya angka 0 saja atau tidak. Jika angka dibelakang koma hanyalah 0, maka
method menghilangkan angka 0 dengan mengambil angka yang berada di depan koma saja dan
menjadikannya hasil untuk kalkulator.

4. Method proses(String status,String op,String a,String b) adalah method utama

dalam class Rumus. Method inilah yang digunakan untuk melakukan perhitungan untuk
kalkulator yang meliputi *, / , + , dan -. Berikut ini merupakan kode method :

public String proses(String st,String op,

11
 String a,String b){
String hasil="";
double hasilDouble=keDouble(b);

if(st.equals("input")){ //tingkat 1
if(op.equals("*")){ //tingkat 2
hasilDouble=keDouble(a)*keDouble(b);
}else if(op.equals("/")){
hasilDouble=keDouble(a)/keDouble(b);
}else if(op.equals("+")){
hasilDouble=keDouble(a)+keDouble(b);
}else if(op.equals("-")){
hasilDouble=keDouble(a)-keDouble(b);
}else if(op.equals(" ")){
return hasil = b;
} //akhir tingkat 2
} //akhir tingkat 1
return hasil = bulatkan(hasilDouble);
}

Method proses() diatas akan dipanggil dari class FormKalkulator. Ketika dipanggil, method
ini harus mengikutkan 4 parameter. Berikut penjelasan mengenai peranan ke-4 parameter yang
dimaksud :

- String st : merupakan parameter yang berisi status dari class FormKalkulator. Status ini
memiliki 2 jenis nilai yaitu “input” dan “output” nilai status ini tergantung jenis tombol yang
ditekan pada kalkulator. Jika tombol yang ditekan adalah tombol angka, maka status yang
dikirim dalam st bernilai “input”. Sedangkan jika yang ditekan adalah tombol operator, maka
parameter st bernilai “output”.

- String op : parameter ini bernilai operator yang sedang aktif pada FormKalkulator yaitu *, /
, + , atau -.

- String a dan b : adalah nilai yang akan dihitung atau dioperasikan oleh operator op.

Ke-4 parameter di atas akan diproses oleh method proses() dan method lain dalam class Rumus.
Hasil pengolahan akan dikirim kembali ke class FormKalkulator untuk ditampilkan di layar
kalkulator. Proses yang terjadi ketika class ini dipanggil melalui method proses() adalah sebagai
berikut :

- Mulai dari dalam method proses(), sebuah pengecekan oleh struktur kontrol if yang diberi
label tingkat 1 dengan memeriksa nilai parameter st. pemeriksaan ini hanya akan dilanjutkan
ke proses berikutnya jika status st bernilai “input”. Pemeriksaan ini untuk mencegah proses
ketika tombol operator ditekan secara berurutan. Misalnya kasus perhitungan 5 + x 6 =.
Ketika tombol x, operator + tidak akan diproses karena mengirimkan mengirimkan status
“output” kedalam method proses().

- Proses akan dilanjutkan jika lolos pada tingkat 1, yaitu if tingkat 2 akan dijalankan dengan
mengevaluasi operator yang ada pada nilai parameter op ( disesuaikan dengan operator *, /, +,
- ). Masing-masing blok terlebih dahulu mengkonversi tipe data nilai a dan b menjadi
double sebelum melakukan perhitungan. Method yang melakukan konversi ini adalah mehtod
keDouble(String angkaString).

- Setelah didapat hasil perhitungan angka a dan b, hasil tersebut dibulatkan dengan method
bulatkan(double angkaDouble). pembulatan ini berfungsi untuk menghalangkan angka 0

12
 seperti yang sudah dibahas pada bagian fungsi method ini. Dalam method ini juga sekaligus
melakukan konversi kembali hasil perhitungan menjadi tipe String dengan method
keString(double angkaDouble)

Demikianlah proses pengolahan angka yang terjadi pada class Rumus. Berikut kode lengkap class ini
:

Kode . Rumus.java
1. package fungsi;
2
3. public class Rumus {
4. double keDouble(String angkaString){ return
5. Double.parseDouble(angkaString);
6. }
7.
8. String keString(double angkaDouble){ return
9. Double.toString(angkaDouble);
10. }
11.
12. String bulatkan(double angkaDouble){ String
13. hasil=keString(angkaDouble); int indexKoma =
14. hasil.indexOf('.');
15. if(hasil.substring(indexKoma+1).equals("0")){
16. hasil = hasil.substring(0,indexKoma);
17. }
18. return hasil;
19. }
20.
21. public String proses(String st,String op,
22. String a,String b){
23. String hasil="";
24. double hasilDouble=keDouble(b);
25.
26. if(st.equals("input")){ //tingkat 1
27. if(op.equals("*")){ //tingkat 2
28. hasilDouble=keDouble(a)*keDouble(b);
29. }else if(op.equals("/"))
30. { hasilDouble=keDouble(a)/keDouble(b);
31. }else if(op.equals("+"))
32. { hasilDouble=keDouble(a)+keDouble(b);

33. }else if(op.equals("-"))

34. { hasilDouble=keDouble(a)-keDouble(b);
35. }else if(op.equals(" ")){ return hasil =
36. b;
37. } //akhir tingkat 2
38. } //akhir tingkat 1
39. return hasil = bulatkan(hasilDouble);
40. }
41. }

Memberi fungsi tombol

Pada bagian ini, kita akan kembali pada tampilan Source ( kode ) class FormKalkulator. Agar
tombol dapat berfungsi seperti layaknya kalkulator, silahkan anda ikuti langkah-langkah untuk
memberikan kode fungsi pada tombol berikut ini :

1. Buatlah variabel-variabel berikut ini dibawah pendeklarasian class FormKalkulator.

public class FormKalkulator extends javax.swing.JFrame {

public String hasil="0";
public String status="input";

13
 public String op=" ";
public String plusmin = "plus";
Rumus rumus = new Rumus();

Keterangan :
- Hasil : adalah variabel yang menyimpan hasil pengoperasian angka yang akan
ditampilkan dilayar

- status : adalah variabel yang menyimpan status kalkulator. Ada dua nilai untuk variabel
ini yaitu “input” dan “output”. Jika yang ditekan adalah tombol angka, maka nilai status
adalah “input”. Tetapi jika tombol operasi yang ditekan, nilai status berubah menjadi
“output”.

- op : adalah variabel yang menyimpan jenis operator yang akan digunakan untuk
mengoperasikan angka ( *,/,+, - ).

- plusmin : adalah variabel yang berfungsi sebagai keterangan untuk angka yang tampil
pada layar apakah positif atau negative.

- rumus : adalah objek baru dari class Rumus yang akan digunakan untuk mengakses
method
proses() dari class Rumus.

2. Buatlah method setAngka() yang nantinya berfungsi untuk menampilkan angka pada layar
kalkulator. Buatlah method ini dibawah konstruktor FormKalkulator sesuai dengan gambar
berikut :

Gambar 5.16 Urutan isi class FormKalkulator

Berikut kode dari method setAngka():

void setAngka(String angka)

{ if(status.equals("input")){ //tingkat
1
if(layar.getText().equals("0")){ //tingkat 2
layar.setText(angka);
}else {
layar.setText(layar.getText()+angka);
} //akhir tingkat 2
}else if(status.equals("output")){
layar.setText(angka);
} //akhir tingkat 1
status = "input";
}

Dalam method setAngka() ini , ada 2 tingkat struktur control if yang harus dilewati untuk
menampilkan angka pada layar. Berikut perbedaan tingkat if yang dimaksud :
14
 - Pada if tingkat 1, jika variabel status bernilai “input” maka angka ditampilkan bersama
dengan angka sebelumnya. Misalkan kita mengetik angka 25. Setelah menekan angka 2 dan
kemudian diikuti dengan angka 5, maka angka 5 akan disambung dengan angka 2 menjadi
25. Hal ini berbeda jika status bernilai “output”, angka yang pertama muncul akan hilang
dan digantikan dengan angka yang terakhir ditekan. Misalnya 2 + 5. Pada saan menekan
tombol “+”, maka status akan bernilai “output” sehingga angka 2 akan hilang diganti
dengan angka 5 pada saat tombol 5 di tekan.

- if tingkat 2 dijalankan pada saat status bernilai “input”. Fungsi if pada tingkat ini akan
mengevaluasi angka yang akan disambung pada layar. Jika yang tampil sebelumnya adalah
0, maka angka selanjutnya saja yang ditampilkan. Misalnya kombinasi tombol yang ditekan
adalah 05, maka yang tampil dilayar hanyalah angka 5. Tetapi jika angka pertama bukan 0,
maka angka pertaman akan tetap ditampilkan dan disambung dengan angka selanjutnya.

Pada bagian akhir method, variabel status diberikan nilai “input”. Pemberian nilai ini
dilakukan karena method setAngka() akan dipanggil jika tombol angka ditekan sehingga
status haruslah bernilai “input”.

3. Langkah selanjutnya adalah menambahkan kode untuk tombol angka. Agar angka dapat tampil
pada layar pada saat tombol ditekan, method setAngka() yang telah dibuat sebelumnya
ditambahkan pada action tombol tersebut. Cara melakukan hal ini adalah dengan meng-klik
kanan pada tombol yang akan ditambahkan action, pilihlah tombol 0 sebagai contoh. Pilihlah
Events  Action  actionPerformed. Setelah melakukan langkah tersebut, tampilan NetBeans
akan berubah menjadi tampilan Source dimana tempat kode action untuk tombol 0
ditambahkan. Tambahkanlah kode setAngka(“0”) seperti pada kode berikut :

private void tombol0ActionPerformed(ActionEvent evt) {

setAngka("0");
} .

Kode yang backgrounnya warna abu-abu menandakan hasil generate NetBeans. Kode ini tidak
dapat diedit. Lakukanlah hal yang sama pada tombol 1 sampai 9 dengan menggantikan angka 0
pada parameter setAngka(“0”) sesuai dengan tombol masing masing. Berikut kodenya :

- Kode action tombol 1

private void tombol1ActionPerformed(ActionEvent evt){

setAngka("1");
} .

- Kode action tombol 2

private void tombol2ActionPerformed(ActionEvent evt) {
setAngka("2");
} .

- Kode action tombol 3

private void tombol3ActionPerformed(ActionEvent evt) {

setAngka("3");
} .

- Kode action tombol 4

private void tombol4ActionPerformed(ActionEvent evt) {

setAngka("4");

15
 } .

- Kode action tombol 5

private void tombol5ActionPerformed(ActionEvent evt) {

setAngka("5");
} .

- Kode action tombol 6

private void tombol6ActionPerformed(ActionEvent evt) {

setAngka("6");
} .

- Kode action tombol 7

private void tombol7ActionPerformed(ActionEvent evt) {

setAngka("7");
} .

- Kode action tombol 8

private void tombol8ActionPerformed(ActionEvent evt) {

setAngka("8");
} .

- Kode action tombol 9

private void tombol9ActionPerformed(ActionEvent evt) {

setAngka("9");
} .

4. Setelah menambahkan action pada tombol angka, selanjutnya adalah memberikan action
untuk tombol operator. Cara lain untuk memberikan action pada tombol adalah dengan
double klik pada tombol tersebut. Cobalah double klik pada tombol kali dan tambahkan kode
seperti berikut :

private void tombolKaliActionPerformed(ActionEvent evt)

{ hasil = rumus.proses(status,op, hasil,
layar.getText()); layar.setText(hasil);
op = "*";
status="output";
} .

Proses yang terjadi pertama kali pada kode di atas adalah mencari hasil pengoperasian angka
dengan method proses() dari class Rumus. Selanjutnya, hasil yang diperoleh dari method
proses() ditampilkan ke layar kalkulator menggunakan method setText(hasil);. Baris
berikutnya memberikan nilai kali (*) pada variable op yang menandakan operator yang aktif
adalah kali (*) . terakhir adalah pemberian nilai status menjadi “output”. Ingat kembali bahwa
status “output” aktif jika menekan tombol operator dan “input” jika yang ditekan adalah tombol
angka.

Tambahkanlah kode action untuk tombol bagi (/), tambah (+), kurang (-) dan sama dengan (=)
dengan menyesuaikan nilai pada variabel op seperti kode berikut:

- Kode action tombol bagi (/)

16
 private void tombolBagiActionPerformed(ActionEvent evt)
{ hasil = rumus.proses(status,op, hasil,
layar.getText()); layar.setText(hasil);
op = "/";
status="output";
} .

- Kode action tombol tambah (+)

private void tombolTambahActionPerformed(ActionEvent evt) {

hasil = rumus.proses(status,op, hasil, layar.getText());
layar.setText(hasil);
op = "+";
status="output";
} .

- Kode action tombol kurang (-)

private void tombolKurangActionPerformed(ActionEvent evt) {

hasil = rumus.proses(status,op, hasil, layar.getText());
layar.setText(hasil);
op = "-";
status="output";
} .

- Kode action tombol sama dengan (=)

private void tombolSamaDenganActionPerformed(ActionEvent evt) {

hasil = rumus.proses(status,op, hasil, layar.getText());
layar.setText(hasil);
op = "=";
status="output";
hasil="0";
} .

Kode action sama dengan (=) sedikit berbeda dengan kode action pada tombol operator lain.
Pada bagian akhir kode action, ditambahkan kode hasil="0"; yang berfungsi untuk agar
perhitungan berikutnya setelah tombol (=) dimulai kembali dari 0.

5. Langkah berikutnya, tambahkanlah kode action untuk tombol koma agar dapat mendukung
perhitungan angka decimal. Koma yang dikenal java dalam perhitungan adalah titik “ . “ ) .
berikut kodenya action yan ditambahkan pada tombol koma :

private void tombolKomaActionPerformed(ActionEvent evt){

String layarTeks = layar.getText();

boolean koma = false;
for(int i=0;i < layarTeks.length() ; i++){
if(layarTeks.charAt(i)=='.'){
koma = true;
break;
}
}

if(!koma){
layarTeks = layarTeks+".";
layar.setText(layarTeks);
status="input";
}
} .

17
 Ketika tombol koma ditekan, kode action di atas terlebih dahulu mengecek angka yang
tampil pada layar sudah memiliki koma sebelumnya atau tidak. Proses ini berfungsi untuk
mencegah terdapat 2 koma sekaligus yang tampil pada layar. Proses pencarian ini
menggunakan perulangan for untuk memeriksa setiap karakter pada layar kalkulator dan
if(layarTeks.charAt(i)=='.'){ untuk menguji karakter apakah koma atau bukan. Jika
benar ditemukan koma, maka nilai variabel koma dirubah menjadi true.

Setelah pemeriksaan karakter selesai, selanjutnya adalah kode untuk menambahkan koma
pada layar. Koma hanya ditambahkan jika nilai variabel koma bernilai false. Kode yang
melakukan pemeriksaan ini adalah if(!koma). Bagian terakhir kode action ini adalah merubah
nilai status menjadi "input" sama halnya dengan tombol angka.

6. Tombol berikutnya yang diberikan aksi adalah tombol plusminus ( ± ). Jika tombol ini ditekan,
pada layar ditambahkan tanda minus ( - ) didepan angka yang tampil, dengan catatan belum
ada tanda minus sebelumnya. Sebaliknya jika tombol ditekan dan sudah terdapat tanda minus,
maka tanda minus akan dihilangkan. Berikut kode yang ditambahkan pada aksi tombol ini
untuk melakukan fungsi tersebut :

private void tombolPlusMinusActionPerformed(ActionEvent evt) {

if(plusmin.equals("plus")){
hasil = "-"+layar.getText();
plusmin="min";
}else if(plusmin.equals("min")){
hasil = layar.getText().substring(1);
plusmin="plus";
}
layar.setText(hasil);
status = "input";
} .

Kode untuk menambahkan tanda minus pada kode diatas adalah hasil = "-
"+layar.getText(). Sedangkan kode untuk menghilangkan tanda minus adalah
layar.getText().subString(1). Index 0 tidak ditampilkan oleh method subString()
yaitu index untuk tanda minus.

7. Tombol Del memiliki fungsi untuk menghapus satu angka pada layar. Untuk melakukan hal
ini, yang pertama dilakukan adalah mencari panjang karakter yang sedang tampil pada layar
kalkulator. Selanjutnya, menampilkan kembali angka pada layar dengan tidak mengikutkan
karakter terakhir. Berikut kode yang perlu ditambahkan pada aksi tombol ini :

private void tombolDelActionPerformed(ActionEvent evt) {

String layarTeks = layar.getText();
int length = layarTeks.length();
layar.setText(layarTeks.substring(0,length-1));
} .

Kode yang tidak mengukutkan angka terakhir pada kode diatas adalah
layarTeks.subString(0,length-1)

8. Tombol terakhir yang perlu ditambahkan aksi adalah tombol C. tombol ini berfungsi untuk
meng-cancel atau membatalkan semua proses seperti halnya kondisi awal kalkulator saat
dijalankan. Proses yang terjadi pada saat tombol ini ditekan adalah mengembalikan angka yang
tampil pada layar menjadi 0, merubah hasil perhitungan menjadi 0, menghapus operator yang
aktif dan mengembalikan nilai status menjadi “input”. Berikut kode untuk melakukan proses
tersebut dan tambahkanlah pada aksi tombol ini :

private void tombolCActionPerformed(ActionEvent evt) {

18
 layar.setText("0");
hasil="0";
op=" ";
status = "input";
} .

Menambahkan Look and Feel

Look and Feel merupakan thema atau tampilan aplikasi java. Look and Feel juga sering dikenal
dengan istilah skin. Look and Feel yang akan digunakan dalam pembahasan ini adalah quaqua.jar
yang dapat anda download secara gratis di internet ( open source ). Untuk memasang quaqua.jar
pada aplikasi kalkulator yang telah dibuat, dilakukan dengan menambahkan quaqua.jar sebagai
library. Berikut langkah-langkahnya :

1. Klik kananlah di atas bagian Library, kemudian pilih Add Library seperti gambar berikut :

Gambar 5.17 Pilihan menambah library

2. Pada kotak dialog Add Library yang muncul, pilihlah tombol create. Selanjutnya isilah Library
Name dengan “skinKalkulator” atau nama lain yang anda kehendaki. berikut tampilan kotak
dialog yang dimaksud :

Gambar 5.18 Kotak dialog Add Library

19
Setelah muncul tampilan seperti di atas, pilihlah tombol OK untuk membuat library. Jika
berhasil, maka akan muncul kotak dialog Customize Library. Tujuan dari kotak dialog ini
adalah memasukkan quaqua.jar ke dalam library. Carilah file quaqua.jar yang sudah anda
download dengan menekan tombol Add Jar/Folder sehingga muncul kotak browse Jar/Folder.
Setelah memilih quaqua.jar, jangan lupa centang pilihan Copy to Libraries Folder agar file
quaqua.jar dikopy le dalam folder library aplikasi kalkulator. Berikut gambar kotak dialog
yang dimaksud :

Gambar 5.19 Menambahkan file Library

Jika proses berhasil, Libarary “skinKalkulator” yang dibuat tadi akan muncul pada kotak dialog
Add Library. Berikut tampilannya :

Gambar 5.20 Menambahkan file Library

Pilihlah tombol Add Library untuk memasukkan library “skinKalkulator” pada aplikasi
kalkulator. Setelah proses berhasil, maka akan tampil quaqua.jar pada bagian Libraries seperti
gambar berikut :

20
 Gambar 5.21 Tampilan Libraries

3. Langkah selanjutnya adalah mengaplikasikan quaqua.jar pada class FormKalkulator. Pada

tampilan Source class FormKalkulator, tambahkanlah method setSkin() di bawah
setAngka(String angka) seperti pada gambar urutan method FormKalkulator berikut :

Gambar 5.22 Urutan isi class FormKalkulator

Kode method setSkin() yang ditambahkan adalah :

public static void setSkin() {

UIManager.setLookAndFeel(new QuaquaLookAndFeel());
}

Method setSkin()ditambahkan kode static karena method ini akan diakses dari dalam
method main() static juga . Setelah anda ketik, kode di atas akan mengalami eror. Hal ini
disebabkan kode UIManager dan QuaquaLookAndFeel() tidak dapat diakses karena berada
dalam paket yang berbeda dengan class FormKalkulator, melainkan berada dalam Libraries.

Masih ingat syarat agar suatu class dapat mengakses objek yang berbeda paket ?. caranya
adalah dengan mengimport class yang akan diakses. Untuk melakukan hal ini, kliklah tanda
bola lampu di samping kode yang eror.pilihlah import untuk UIManager dan
QuaquaLookAndFeel(). Jika berhasil, kode import akan ditambahkan di atas pendeklarasian
class FormKalkulator seperti berikut :

import javax.swing.UIManager;
import ch.randelshofer.quaqua.QuaquaLookAndFeel;

public class FormKalkulator extends javax.swing.JFrame {

import telah berhasil, namun kode akan tetap mengalami eror. Hal ini dikarenakan NetBeans
mendeteksi kemungkinan terjadi ketidak cocokan Look and Feel dengan system. Untuk
mengatasi eror, dapat dilakukan dengan menambahkan kode yang eror ke dalam blok try
catch. Bloklah baris kode yang eror, kemudian klik bola lampu dan pilih “Sorround with
try
{..}”.hasilnya, baris yang eror akan dibungkus dalam blok try catch seperti berikut :

public static void setSkin() {

try {

21
 UIManager.setLookAndFeel(new QuaquaLookAndFeel());
} catch (UnsupportedLookAndFeelException e) {
}
}

Setelah tidak ada eror lagi, editlah method main dengan menambahkan kode setSkin() untuk
memaanggil method ini. Berikut kodenya :

public static void main(String args[])

{ java.awt.EventQueue.invokeLater(new
Runnable(){
public void run() {
setSkin();
new FormKalkulator().setVisible(true);
}
});
}

Cobalah anda jalankan kalkulator anda untuk melihat perubahan pada tampilannya. Jika
proses berhasil, tampilan kalkulator akan berubah seperti gambar berikut :

Gambar 5.23 Tampilan Look And Feel Kalkulator

4. Tahap terakhir, kalkulator yang telah dibuat akan ditambahkan icon agar tampilannya lebih
menarik. Gambar icon yang akan saya tambahkan sebagai contoh adalah gambar berikut :

Gambar 5.24 Gambar icon.png

Anda dapat menggunakan icon lain sesuai dengan selera anda. Simpanlah gambar icon yang
anda inginkan pada package form seperti gambar berikut :

22
 Gambar 5.25 Struktur File Project

Untuk menampilkan icon pada aplikasi kalkulator, editlah konstruktor FormKalkulator()

seperti kode berikut :

public FormKalkulator() {
initComponents();
layar.setText("0");
// menambahkan icon
String path = System.getProperty("user.dir");
mageIcon icon = new
ImageIcon(path+"\\src\\form\\icon.png");
this.setIconImage(icon.getImage());
}

Kode ImageIcon di atas akan mengalami eror karena class ini perlu diimport terlebih dahulu.
Importlah ImageIcon dengan mengklik bola lampu disamping kode. Jika berhasil, eror pada
kode ImageIcon akan hilang.

Selanjutnya, cobalah anda jalankan program kalkulator anda untuk melihat hasil icon yang
ditambahkan. Jika berhasil, tampilan kalkulator seperti gambar berikut :

Gambar 5.26 Tampilan icon Kalkulator

5. Agar kalkulator dapat dijalankan tanpa menggunakan NetBeans, lakukanlah proses Clean and
Build dengan mengklik kanan di atas Project Kalkulator kemudian pilih Clean and Build.
Proses ini akan menghasilkan file Kalkulator.jar yang dapat dijalankan tanpa NetBeans. File
ini tersimpan dalam folder dist dalam project.

23
 Gambar 5.26 Letak file Kalkulator.jar

Untuk menjalankannya, tinggal didouble klik file Kalkulator.jar. jika anda ingin lebih
mudah mengakses kalkulatornya, tinggal dibuat shortcut-nya saja. Klik kanan di atas file
Kalkulator.jar , kemudian pilih sent to Dekstop. Shortcut sudah siap di desktop anda.

Gambar 5.26 Shortcut Kalkulator.jar di Dekstop

24
25