Bab ini memperluas kemampuan program dengan menggunakan kelas‑kelas pustaka (library classes) yang lebih canggih, struktur data tambahan seperti Maps dan Sets, serta fitur Java seperti static, final, serta autoboxing. Tujuannya agar program bukan hanya “jalan”, tapi bisa punya perilaku yang lebih variatif, lebih modular, dan lebih kuat.
1. Dokumentasi Kelas Library / Membaca API Java
Penjelasan
Java punya banyak kelas bawaan (library classes) di paket seperti java.util, java.lang, java.io, dll. Dokumentasi (API docs / Javadoc) menjelaskan kelas, konstruktor, metode, parameter, tipe kembalian, pengecualian yang mungkin dilempar, dan deskripsi fungsi. Kita tidak perlu mengetahui isi internal, tapi tahu cara pakainya dari dokumentasi.
Contoh
Misalnya kita ingin menggunakan kelas java.util.Random. Kita baca dokumennya dan tahu ada metode nextInt(int bound) yang menghasilkan integer 0 sampai bound‑1.
Kode 1
import java.util.Random; public class ContohRandom { public static void main(String[] args) { Random rnd = new Random(); int x = rnd.nextInt(10); // menghasilkan 0..9 System.out.println("Nilai acak: " + x); } }
https://codeformatter.blogspot.com/
2. Sistem TechSupport (Contoh Proyek)
Idenya: kita punya kelas yang menyimpan peta (map) dari kata kunci ke jawaban yang sesuai, lalu ketika pengguna mengetik kalimat, kita memecah kalimat menjadi kata (token), dan jika ada kata yang cocok, kita pilih jawaban terkait.
Kode 2
import java.util.Map;
import java.util.HashMap;
import java.util.Random;
public class TechSupport {
private Map<String, String> responses;
private Random random;
public TechSupport() {
responses = new HashMap<>();
random = new Random();
// beberapa pasangan kata kunci → respons
responses.put("error", "Apakah Anda menerima pesan kesalahan? Coba restart sistem.");
responses.put("help", "Apa yang bisa saya bantu?");
responses.put("crash", "Kapan crash terjadi? Apakah ada pesan spesifik?");
responses.put("slow", "Sudahkah Anda memeriksa penggunaan CPU dan RAM?");
}
public String getResponse(String userInput) {
String[] words = userInput.toLowerCase().split("\\s+");
for (String w : words) {
if (responses.containsKey(w)) {
return responses.get(w);
}
}
// kalau tidak ada kata kunci cocok, jawaban acak generik
String[] generic = {
"Coba jelaskan lebih rinci.",
"Saya belum mengerti, bisa ulangi?",
"Bisakah Anda memberi detail lebih lanjut?"
};
return generic[random.nextInt(generic.length)];
}
public static void main(String[] args) {
TechSupport ts = new TechSupport();
System.out.println(ts.getResponse("My computer is slow after update"));
System.out.println(ts.getResponse("I need help"));
System.out.println(ts.getResponse("It gives an unknown error"));
}
}
3. Menambahkan Perilaku Acak (Random)
Dengan menggunakan java.util.Random (atau ThreadLocalRandom), kita bisa membuat program mengambil keputusan acak, memilih satu dari beberapa pilihan, atau berubah‑ubah tingkah laku sehingga tidak selalu sama. Hal ini membuat program terasa lebih variatif, tidak monoton.
Kode 3
// dalam kelas TechSupport:
String[] generic = {
"Coba jelaskan lebih rinci.",
"Saya belum mengerti, bisa ulangi?",
"Bisakah Anda memberi detail lebih lanjut?"
};
return generic[random.nextInt(generic.length)];
responses.put("error", "error1|error2|error3"); // gabung menggunakan '|'
...
String val = responses.get(w);
if (val.contains("|")) {
String[] options = val.split("\\|");
return options[random.nextInt(options.length)];
} else {
return val;
}
4. Paket (Packages) dan Pernyataan import
Paket (package) adalah cara Java mengorganisasi kelas agar tidak bercampur aduk. Misalnya java.util, java.io, java.lang. Jika kita ingin menggunakan kelas dari paket yang bukan java.lang (yang otomatis diimpor), kita perlu menggunakan import.
Kode 4
import java.util.HashMap;
import java.util.Map;
public class Aplikasi {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("satu", 1);
System.out.println(map.get("satu"));
}
}
5. Menggunakan Maps untuk Asosiasi (Key‑Value)
Map<K, V> adalah struktur data yang menyimpan pasangan kunci ke nilai. Kunci unik, dan kita bisa mendapatkan nilai dari kunci secara cepat (biasanya dengan waktu rata-rata O(1) untuk HashMap). Sangat cocok untuk situasi seperti “kata → respons”, “nama → objek”, “id → data”, dll.
Kode 5
import java.util.HashMap;
import java.util.Map;
public class ContohMap {
public static void main(String[] args) {
Map<String, String> countryToCapital = new HashMap<>();
countryToCapital.put("Indonesia", "Jakarta");
countryToCapital.put("Japan", "Tokyo");
countryToCapital.put("France", "Paris");
System.out.println("Ibukota Indonesia: " + countryToCapital.get("Indonesia"));
String key = "Germany";
if (countryToCapital.containsKey(key)) {
System.out.println("Ibukota " + key + ": " + countryToCapital.get(key));
} else {
System.out.println(key + " tidak ada dalam peta.");
}
}
}
6. Menggunakan Sets
Set<E> adalah kumpulan elemen unik (tidak ada duplikat). Berguna ketika kita ingin menyimpan sekumpulan nilai dan memastikan tidak ada nilai yang sama dua kali. Ada implementasi seperti HashSet, TreeSet (urut), dll.
import java.util.HashSet;
import java.util.Set;
public class ContohSet {
public static void main(String[] args) {
Set<String> kataKunci = new HashSet<>();
kataKunci.add("error");
kataKunci.add("help");
kataKunci.add("error"); // duplikat — tidak akan ditambahkan lagi
System.out.println("Set ukuran: " + kataKunci.size()); // hasil 2
if (kataKunci.contains("help")) {
System.out.println("Termasuk kata 'help'");
}
}
}
7. Memecah String / Tokenisasi
Untuk mengurai masukan pengguna (kalimat) menjadi kata‑kata (token), kita bisa menggunakan metode split(...) atau kelas StringTokenizer atau Scanner. Tokenisasi penting agar kita bisa menganalisis kata kata di masukan, mencari kata kunci, menghitung kemunculan kata, dsb.
String input = "My computer gives error and then crash";
String[] tokens = input.toLowerCase().split("\\s+");
for (String t : tokens) {
System.out.println("Token: " + t);
}
8. static, final, Variabel Kelas dan Konstanta
Penggunaan
-
static
Menandakan bahwa variabel atau metode milik kelas, bukan milik objek individu. Semua objek kelas yang sama akan berbagi variabelstaticyang sama. -
final
Menandakan bahwa variabel nilainya tidak dapat diubah setelah diinisialisasi (konstanta). Untuk metode,finalmencegah metode di‐override di subclass. -
Kombinasi sering:
static finaluntuk konstanta kelas.
public class KonstantaContoh {
public static final int MAX_TRIES = 5; // konstanta
private static int counter = 0; // variabel kelas
public static void doSomething() {
counter++;
System.out.println("Dipanggil ke: " + counter);
}
public static void main(String[] args) {
for (int i = 0; i < MAX_TRIES; i++) {
KonstantaContoh.doSomething();
}
// MAX_TRIES = 10; // error: tidak bisa diubah karena final
}
}
Penjelasan tambahan:
-
counteradalah variabel milik kelas, tidak milik objek. Semua pemanggilandoSomethingmempengaruhicounteryang sama. -
MAX_TRIESadalah konstanta, nilainya tetap (tidak bisa diubah). -
Karena ini
static, kita bisa memanggilKonstantaContoh.doSomething()tanpa membuat objeknya.
9. Autoboxing dan Wrapper Classes
Koleksi generik di Java (seperti ArrayList<T>) hanya menerima tipe objek (reference types), bukan tipe primitif (int, double, boolean, dll). Agar bisa menyimpan nilai primitif, Java menyediakan wrapper classes seperti Integer, Double, Boolean, dll. Autoboxing adalah fitur yang secara otomatis mengkonversi primitif ke objek wrapper dan unboxing kebalikannya.
import java.util.ArrayList;
import java.util.List;
public class ContohAutoboxing {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(10); // autoboxing: 10 (int) jadi Integer.valueOf(10)
list.add(20);
list.add(30);
int total = 0;
for (Integer x : list) {
total += x; // unboxing: x.intValue()
}
System.out.println("Total: " + total);
}
}
10. Penulisan Dokumentasi Sendiri (Javadoc)
Agar kode kita mudah dipahami oleh orang lain (atau kita sendiri nanti), penting untuk memberikan dokumentasi di kelas, metode, parameter, dan nilai kembaliannya (return). Java menyediakan standar dokumentasi via Javadoc (komentar yang dimulai /** … */) yang bisa dikonversi menjadi HTML dokumentasi.
/**
* Kelas ini memberikan layanan teknis sederhana
* berdasarkan kata kunci dalam masukan pengguna.
*/
public class TechSupport {
private Map<String, String> responses;
/**
* Konstruktor: membuat instance TechSupport
* dengan peta respons bawaan.
*/
public TechSupport() {
responses = new HashMap<>();
responses.put("error", "Pesan kesalahan...");
// ...
}
/**
* Menghasilkan respons terhadap masukan pengguna.
* Mencari kata kunci dalam masukan; jika tidak ada,
* mengembalikan jawaban generik acak.
*
* @param userInput masukan pengguna (kalimat bebas)
* @return respons sistem sebagai String
*/
public String getResponse(String userInput) {
// implementasi...
}
}
