Sekarang kita akan belajar apa itu classpath, imports, file java, file class, file jar, swing, dan hal-hal yang berkaitan erat dengan pemrograman Java lebih dalam daripada sekedar HelloWorld.
Saya akan tetap menggunakan editor sederhana seperti notepad dan melakukan semuanya secara manual. Mengapa tidak langsung pakai editor seperti Eclipse, Netbeans atau IDE canggih yang lain ?
Alasan pertama, karena ini akan membuat kita memahami “behind the scene things”, yang merupakan fundamental dari Java, sehingga ketika kita menggunakan IDE yang canggih, kita sudah mengetahui, apa yang sebenarnya terjadi.
Alasan kedua, supaya saya bisa berbagi tentang eclipse atau netbeans di artikel berikutnya…
Tipe Data
Java mengenal 2 macam tipe data. Yang pertama adalah tipe data primitif, yaitu byte, short, char, int, long, float, dan double. Yang kedua adalah tipe data object. Ini adalah tipe yang dibuat dari definisi class. Root class di Java adalah class Object, semua class yang ada di library java maupun yang kita buat sendiri adalah turunan dari class Object.
Ok, mari kita mulai dengan membuat aplikasi Kalkulator. Direktori kerja saya saat ini adalah C:\Java. Buka notepad, kemudian ketik kode berikut (saya tetap berpendapat bahwa mengetik lebih baik daripada copy and paste).
package suhearie.blog.morehelloworld;
public class Kalkulator {
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("Penggunaan: java Kalkulator operand1 operand2");
}
else {
System.out.println("Hasil: 5");
}
}
}
Kemudian lakukan langkah-langkah berikut:
- Buat file source code. Save kode tersebut sebagai file source code dengan nama file Kalkulator.java. File source code harus memiliki extension .java dan harus sesuai dengan nama class utama, dalam hal ini Kalkulator.
- Package adalah mekanisme pengelompokan source code. Karena saya menggunakan nama package suhearie.blog.morehelloworld, maka kita harus membuat struktur direktori yang mencerminkan package tersebut, dan meletakkan file source kita disana.
- Compile source code. Buka command prompt, masuk ke direktori C:\Java, ketik
javac suhearie/blog/morehelloworld/*.java. javac adalah compiler java. Jika kompilasi berhasil, javac akan menghasilkan file Kalkulator.class. Ini adalah file class (disebut juga bytecode) yang akan dieksekusi oleh Java Virtual Machine (JVM) pada saat runtime.
- Jalankan aplikasi. Di command prompt, ketik java suhearie.blog.morehelloword.Kalkulator. Perintah ini akan menjalankan JVM dan mengeksekusi kode yang ada di dalam method public static void main(String[ ] args) { }. String[ ] args adalah variable bertipe string array untuk menampung argumen yang kita berikan saat memulai aplikasi.
Sejauh ini aplikasi kalkulator kita hanya melakukan print ke standard-output, ditambah logika sederhana untuk memeriksa apakah user sudah memasukkan dua argumen saat menjalankan aplikasi. Tapi hasilnya masih salah karena kita hanya menghasilkan nilai konstan tanpa memperdulikan input.
Saatnya mengimplementasikan perhitungan yang sebenarnya pada aplikasi ini. Saya melakukannya dengan:
1. Membuat constructor. Constructor adalah method spesial dalam sebuah class. Sesuai namanya, blok kode ini dipanggil untuk meng-construct object baru. Method ini tidak mempunyai return type, dan namanya harus sama persis dengan nama class.
2. Membuat method baru. Method tersebut bernama jumlahkan, tujuannya untuk menghitung jumlah dari dua buah input yang diberikan
package suhearie.blog.morehelloworld;
public class Kalkulator {
public Kalkulator() {
System.out.println("Kalkulator baru saja dibuat");
}
private int jumlahkan(String operand1, String operand2) {
int x = Integer.parseInt(operand1);
int y = Integer.parseInt(operand2);
int hasil = x + y;
return hasil;
}
public static void main(String[] args) {
if (args.length == 2) {
Kalkulator myKalkulator = new Kalkulator();
int hasil = myKalkulator.jumlahkan(args[0], args[1]);
System.out.println("Hasil: "+hasil);
}
else {
System.out.println("Penggunaan: java Kalkulator operand1 operand2");
}
}
}Saatnya melakukan refactor, yaitu membuat code menjadi lebih reusable, agar kita bisa mendapatkan manfaat dari OOP. Kita akan membuat sebuah class baru yang bertugas sebagai “engine” untuk melakukan perhitungan.
Class KalkulatorEngine
package suhearie.blog.morehelloworld;
public class KalkulatorEngine {
public int hitung(String operasi, String operand1, String operand2) {
int x = Integer.parseInt(operand1);
int y = Integer.parseInt(operand2);
if (operasi.equals("tambah")) {
return tambah(x, y);
}
else if (operasi.equals("kurang")) {
return kurang(x, y);
}
else {
System.out.println("Kalkulator tidak mendukung operasi "+operasi);
return 0;
}
}
private int tambah(int operand1, int operand2) {
return operand1 + operand2;
}
private int kurang(int operand1, int operand2) {
return operand1 - operand2;
}
}Integer.parseInt() adalah sintaks untuk mengubah dari String ke bilangan integer.
Class Kalkulato
package suhearie.blog.morehelloworld;
public class Kalkulator {
private KalkulatorEngine engine = null;
public Kalkulator() {
System.out.println("Menyiapkan engine");
engine = new KalkulatorEngine();
System.out.println("Kalkulator baru saja dibuat");
}
private int hitung(String operasi, String operand1, String operand2) {
return engine.hitung(operasi, operand1, operand2);
}
public static void main(String[] args) {
if (args.length == 3) {
Kalkulator myKalkulator = new Kalkulator();
int hasil = myKalkulator.hitung(args[0], args[1], args[2]);
System.out.println("Hasil: "+hasil);
}
else {
System.out.println("Penggunaan: java Kalkulator operasi operand1 operand2");
}
}
}Di Class Kalkulator yang telah diperbaharui ini, kita tidak lagi melakukan perhitungan di dalam class ini. Kita meng-create sebuah object KalkulatorEngine, dan menyuruh engine ini untuk melakukan perhitungan.
Class Kalkulator yang sudah kita buat adalah aplikasi berbasis text. Sekarang kita akan membuat sebuah class baru yang berbasis Graphical User Interface (GUI). Library standard Java untuk membuat GUI adalah Swing dan AWT. Sebelum mendeklarasikan class, kita melakukan import terlebih dahulu dari library yang kita butuhkan untuk memberi tahu compiler, bahwa kita akan menggunakan class-class yang berasal dari library tersebut. Kali ini kita akan mengimport semua class dari package javax.swing dan package java.awt.event.
JFrame adalah class yang kita gunakan untuk membuat window di Java. Kita akan membuat class baru yang meng-extend class JFrame ini. Selanjutnya, kita masukkan semua komponen yang kita butuhkan yaitu, JLabel untuk label, JComboBox untuk dropdown box, JTextField untuk text box, dan JButton untuk tombol.
Setelah membuat GUI nya, kita menambahkan action listener pada komponen tombol, sehingga ketika tombol tersebut di-klik oleh user, kita bisa melakukan action yang kita inginkan, dalam hal ini memanggil engine untuk melakukan perhitungan dan menampilkannya pada kotak hasil.
Class KalkulatorGUI
package suhearie.blog.morehelloworld;
import java.awt.event.*;
import javax.swing.*;
public class KalkulatorGUI extends JFrame {
private KalkulatorEngine engine;
private JComboBox comboOperasi;
private JTextField txtOperand1;
private JTextField txtOperand2;
private JButton btnHitung;
private JTextField txtHasil;
public KalkulatorGUI() {
System.out.println("Menyiapkan engine");
engine = new KalkulatorEngine();
System.out.println("Menyiapkan GUI");
setTitle("Kalkulator GUI");
setContentPane(createGUI());
setupAction();
setSize(600, 100);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private JPanel createGUI() {
JPanel panel = new JPanel();
// Operasi
panel.add(new JLabel("Operasi"));
comboOperasi = new JComboBox();
comboOperasi.addItem("tambah");
comboOperasi.addItem("kurang");
panel.add(comboOperasi);
// Operand1
panel.add(new JLabel("Operand 1"));
txtOperand1 = new JTextField();
txtOperand1.setColumns(5);
panel.add(txtOperand1);
// Operand2
panel.add(new JLabel("Operand 2"));
txtOperand2 = new JTextField();
txtOperand2.setColumns(5);
panel.add(txtOperand2);
// Tombol Hitung
btnHitung = new JButton("Hitung");
panel.add(btnHitung);
// Hasil
panel.add(new JLabel("Hasil"));
txtHasil = new JTextField();
txtHasil.setColumns(5);
panel.add(txtHasil);
return panel;
}
private void setupAction() {
btnHitung.addActionListener(new MyActionListener());
}
class MyActionListener implements ActionListener {
public void actionPerformed(ActionEvent event) {
String operasi = (String) comboOperasi.getSelectedItem();
String operand1 = txtOperand1.getText();
String operand2 = txtOperand2.getText();
int hasil = engine.hitung(operasi, operand1, operand2);
txtHasil.setText(String.valueOf(hasil));
}
}
public static void main(String[] args) {
KalkulatorGUI kalkulator = new KalkulatorGUI();
kalkulator.setVisible(true);
}
}
Anda akan mendapatkan tampilan seperti gambar berikut. Pilih operasi, masukkan operand 1 dan operand 2, kemudian tekan tombol Hitung, maka hasil perhitungan akan tampil di kotak hasil.
Disini kita dapat melihat keuntungan dari prinsip reusability, karena kita memiliki 2 aplikasi yang berbeda tapi menggunakan engine yang sama untuk melakukan perhitungan.
Ok, sekian untuk tutorial kali ini. Silahkan review kembali kode yang sudah kita buat untuk lebih memahami bagaimana kode tersebut bekerja. Selamat mencoba dan belajar !!
