Seiring program semakin panjang, menulis semua kode di dalam main akan membuatnya berantakan dan berulang. Pada pertemuan terakhir ini kita belajar method (subprogram) untuk memecah program menjadi bagian-bagian kecil yang dapat dipakai ulang, rekursi, serta exception handling agar program tetap tangguh. Pertemuan ini juga menjadi penutup yang merangkum seluruh materi dasar Java dan mengenal fitur terbaru Java 25.

Pendahuluan

Tujuan Pembelajaran

Setelah pertemuan ini, kamu diharapkan mampu:

  • Membuat dan memanggil method dengan parameter dan nilai kembalian.
  • Memahami pass-by-value, scope variabel, overloading, dan varargs.
  • Menulis method rekursif sederhana dengan base case yang benar.
  • Menangani error dengan try, catch, finally, dan throw.
  • Memecah program menjadi beberapa method yang masing-masing melakukan satu tugas.
  • Mengenal fitur Java 25 seperti compact source file dan IO.println.

Alokasi Waktu Pertemuan Ini

Sesi Topik Durasi
Materi 1 Review & konsep method 10 menit
Materi 2 Deklarasi, parameter, dan return 20 menit
Materi 3 Pass-by-value & scope 15 menit
Materi 4 Overloading & varargs 15 menit
Materi 5 Rekursi 15 menit
Materi 6 Exception handling 20 menit
Materi 7 Perancangan method yang baik 10 menit
Materi 8 Penutup: rangkuman & fitur Java 25 15 menit
Total Materi 2 jam
Latihan Latihan Mandiri & Proyek Akhir 1 jam
Total 3 jam

Review Singkat

Dalam lima pertemuan terakhir kita telah mempelajari: instalasi dan program pertama (Pertemuan 1), operator dan String (2), percabangan (3), perulangan (4), serta array dan ArrayList (5). Pertemuan ini menyatukan semuanya.

Konsep Method

Method (di bahasa lain disebut fungsi atau prosedur) adalah blok kode bernama yang melakukan tugas tertentu dan dapat dipanggil berkali-kali. Contoh method yang sudah kita pakai: System.out.println(), Math.sqrt(), dan input.nextInt().

Manfaat method:

  • Menghindari duplikasi kode (DRY: Don’t Repeat Yourself).
  • Memudahkan membaca dan merawat program.
  • Memudahkan pengujian, karena setiap bagian dapat dicoba sendiri.
  • Dapat dipakai ulang pada program lain.

Deklarasi Method

1
2
3
4
static tipeKembalian namaMethod(tipe parameter1, tipe parameter2) {
    // isi method
    return nilai;      // jika tipeKembalian bukan void
}
Bagian Penjelasan
static Method dapat dipanggil langsung dari main tanpa membuat objek (akan dibahas lebih dalam pada materi OOP)
tipeKembalian Tipe nilai yang dikembalikan (int, double, String, dll). Gunakan void jika tidak mengembalikan apa pun
namaMethod Gunakan camelCase berupa kata kerja, contoh: hitungLuas
Parameter Data masukan method, boleh kosong
return Mengembalikan nilai ke pemanggil sekaligus mengakhiri method

Method void (Tanpa Nilai Kembalian)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
    static void sapa(String nama) {
        System.out.println("Halo, " + nama + "!");
    }

    static void garis() {
        System.out.println("=".repeat(20));
    }

    public static void main(String[] args) {
        garis();
        sapa("Zulma");
        sapa("Java");
        garis();
    }
}

Method dengan Return Value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Main {
    static int tambah(int a, int b) {
        return a + b;
    }

    static double luasLingkaran(double jariJari) {
        return Math.PI * jariJari * jariJari;
    }

    static boolean isGenap(int n) {
        return n % 2 == 0;
    }

    static String grade(int nilai) {
        if (nilai >= 85) return "A";
        if (nilai >= 70) return "B";
        if (nilai >= 55) return "C";
        return "D";
    }

    public static void main(String[] args) {
        int hasil = tambah(5, 7);
        System.out.println("5 + 7 = " + hasil);
        System.out.printf("Luas: %.2f%n", luasLingkaran(7));
        System.out.println("10 genap? " + isGenap(10));
        System.out.println("Grade: " + grade(78));
    }
}

Catatan penting:

  • Method yang mengembalikan nilai harus return pada semua kemungkinan jalur eksekusinya, jika tidak terjadi compile error.
  • Nilai yang dikembalikan dapat langsung dipakai dalam ekspresi: System.out.println(tambah(1, 2) * 10);.
  • Method boleh ditulis di mana saja di dalam class (di atas maupun di bawah main), karena kompiler membaca seluruh class terlebih dahulu.

Pass-by-Value dan Scope

Pass-by-Value

Java selalu memberikan salinan nilai ke parameter.

1
2
3
4
5
6
7
8
9
static void ubah(int x) {
    x = 100;                 // hanya mengubah salinan
}

public static void main(String[] args) {
    int angka = 5;
    ubah(angka);
    System.out.println(angka);    // tetap 5
}

Untuk array dan objek, yang disalin adalah referensinya, sehingga isi array yang sama dapat berubah:

1
2
3
4
5
6
7
8
9
10
11
static void gandakan(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] *= 2;          // mengubah array asli
    }
}

public static void main(String[] args) {
    int[] data = {1, 2, 3};
    gandakan(data);
    System.out.println(Arrays.toString(data));    // [2, 4, 6]
}

(Tambahkan import java.util.Arrays; agar kode di atas dapat dikompilasi.)

Scope Variabel

Variabel hanya dikenal di dalam blok { } tempat ia dideklarasikan.

1
2
3
4
5
6
7
8
9
10
static int hitung() {
    int lokal = 10;          // hanya hidup di dalam hitung()
    return lokal * 2;
}

public static void main(String[] args) {
    // System.out.println(lokal);   // ERROR: cannot find symbol
    for (int i = 0; i < 3; i++) { }
    // System.out.println(i);       // ERROR: i hanya ada di dalam for
}

Variabel yang dideklarasikan di luar method (pada level class) disebut field, dan dapat dipakai bersama oleh semua method static:

1
2
3
4
5
6
7
public class Main {
    static final double PPN = 0.11;       // konstanta global

    static double hitungTotal(double harga) {
        return harga + harga * PPN;
    }
}

Overloading dan Varargs

Method Overloading

Beberapa method boleh memiliki nama sama asalkan daftar parameternya berbeda (jumlah atau tipe). Java memilih method yang paling cocok berdasarkan argumen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static int jumlah(int a, int b) {
    return a + b;
}

static double jumlah(double a, double b) {
    return a + b;
}

static int jumlah(int a, int b, int c) {
    return a + b + c;
}

public static void main(String[] args) {
    System.out.println(jumlah(2, 3));          // 5   (int, int)
    System.out.println(jumlah(2.5, 3.5));      // 6.0 (double, double)
    System.out.println(jumlah(1, 2, 3));       // 6   (tiga int)
}

Perbedaan hanya pada tipe kembalian tidak cukup untuk overloading. Contoh nyata overloading: System.out.println() yang dapat menerima int, String, double, dan sebagainya.

Varargs

Varargs memungkinkan method menerima jumlah argumen yang tidak tetap. Di dalam method, parameter tersebut diperlakukan sebagai array.

1
2
3
4
5
6
7
8
9
10
11
12
13
static int jumlahSemua(int... angka) {
    int total = 0;
    for (int n : angka) {
        total += n;
    }
    return total;
}

public static void main(String[] args) {
    System.out.println(jumlahSemua());              // 0
    System.out.println(jumlahSemua(5));             // 5
    System.out.println(jumlahSemua(1, 2, 3, 4));    // 10
}

Parameter varargs harus berada di posisi paling akhir dan hanya boleh ada satu per method.

Rekursi

Rekursi adalah method yang memanggil dirinya sendiri. Setiap method rekursif wajib memiliki:

  1. Base case: kondisi berhenti yang tidak memanggil diri sendiri.
  2. Recursive case: pemanggilan diri dengan masalah yang lebih kecil menuju base case.
1
2
3
4
5
6
7
// n! = n x (n-1)!    dengan 0! = 1
static long faktorial(int n) {
    if (n <= 1) {                 // base case
        return 1;
    }
    return n * faktorial(n - 1);  // recursive case
}

Jejak faktorial(4):

1
2
3
4
5
faktorial(4) = 4 * faktorial(3)
             = 4 * (3 * faktorial(2))
             = 4 * (3 * (2 * faktorial(1)))
             = 4 * (3 * (2 * 1))
             = 24

Contoh lain:

1
2
3
4
5
6
7
8
9
10
11
// Fibonacci: f(0)=0, f(1)=1, f(n)=f(n-1)+f(n-2)
static int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Pangkat: a^b
static long pangkat(long a, int b) {
    if (b == 0) return 1;
    return a * pangkat(a, b - 1);
}

Hal yang perlu diwaspadai:

  • Tanpa base case yang benar, program akan berhenti dengan StackOverflowError.
  • Rekursi Fibonacci di atas sangat lambat untuk n besar karena menghitung ulang nilai yang sama berkali-kali. Versi perulangan (Pertemuan 4) jauh lebih efisien.
  • Setiap masalah rekursif dapat ditulis dengan perulangan. Pilih rekursi bila membuat solusi lebih jelas (misalnya struktur pohon dan folder).

Exception Handling

Pada Pertemuan 1 kita telah mengenal runtime error yang di Java disebut exception. Tanpa penanganan, exception menghentikan program secara mendadak. Dengan exception handling, kita dapat menangkap error tersebut dan memberi respons yang baik kepada pengguna.

try - catch - finally

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {
    public static void main(String[] args) {
        String teks = "abc";

        try {
            int angka = Integer.parseInt(teks);          // bisa melempar exception
            System.out.println("Hasil: " + 100 / angka);
        } catch (NumberFormatException e) {
            System.out.println("Bukan angka yang valid: " + teks);
        } catch (ArithmeticException e) {
            System.out.println("Tidak boleh membagi dengan nol");
        } finally {
            System.out.println("Blok ini SELALU dijalankan");
        }

        System.out.println("Program tetap berjalan sampai akhir.");
    }
}
Bagian Fungsi
try Kode yang berpotensi menimbulkan exception
catch Penanganan untuk jenis exception tertentu (boleh lebih dari satu)
finally Selalu dijalankan, baik terjadi exception maupun tidak (cocok untuk membersihkan resource)

Beberapa tipe exception dapat ditangani bersama dengan multi-catch:

1
2
3
4
5
try {
    // ...
} catch (NumberFormatException | ArithmeticException e) {
    System.out.println("Terjadi kesalahan: " + e.getMessage());
}

Melempar Exception dengan throw

Gunakan throw untuk menandai bahwa sebuah method menerima data yang tidak valid:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static double bagi(double a, double b) {
    if (b == 0) {
        throw new IllegalArgumentException("Pembagi tidak boleh nol");
    }
    return a / b;
}

public static void main(String[] args) {
    try {
        System.out.println(bagi(10, 0));
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
}

Membaca Input Aman dengan Method

Method dapat menyatukan perulangan, Scanner, dan exception handling menjadi satu fungsi yang bisa dipakai ulang:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
    static int bacaInt(Scanner input, String pesan) {
        while (true) {
            System.out.print(pesan);
            try {
                int nilai = input.nextInt();
                input.nextLine();                // buang sisa baris (Enter)
                return nilai;
            } catch (InputMismatchException e) {
                System.out.println("Input harus berupa bilangan bulat!");
                input.nextLine();                // buang input yang salah
            }
        }
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int umur = bacaInt(input, "Masukkan umur: ");
        System.out.println("Umurmu " + umur + " tahun.");
        input.close();
    }
}

Jenis exception yang sering ditemui:

Exception Penyebab
NumberFormatException Integer.parseInt("abc")
InputMismatchException Input Scanner tidak sesuai tipe
ArithmeticException Bilangan bulat dibagi nol
ArrayIndexOutOfBoundsException Indeks array di luar batas
NullPointerException Memakai variabel objek yang masih null
IllegalArgumentException Argumen method tidak valid

Jangan menangkap exception hanya untuk “menyembunyikan” error dengan catch yang kosong. Selalu beri respons yang jelas: pesan ke pengguna, mencoba ulang, atau mencatat log.

Perancangan Method yang Baik

  • Satu method, satu tugas. Jika sebuah method melakukan membaca input, menghitung, dan mencetak sekaligus, pecah menjadi tiga method.
  • Nama berupa kata kerja yang menjelaskan tujuan: hitungRataRata, cetakStruk, isPrima. Method yang mengembalikan boolean biasanya diawali is atau has.
  • Batasi parameter (idealnya tidak lebih dari tiga). Jika data terlalu banyak, kelompokkan dalam array atau objek.
  • Pisahkan perhitungan dan tampilan. Method yang menghitung sebaiknya return hasilnya, bukan langsung mencetak, sehingga mudah diuji dan dipakai ulang.
  • Hindari duplikasi. Kode yang sama ditulis dua kali adalah kandidat method baru.
  • Dokumentasikan dengan Javadoc agar IDE menampilkan petunjuk saat method dipanggil:
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Menghitung rata-rata dari sekumpulan nilai.
 *
 * @param nilai array nilai (tidak boleh kosong)
 * @return rata-rata nilai
 */
static double hitungRataRata(int[] nilai) {
    int total = 0;
    for (int n : nilai) {
        total += n;
    }
    return (double) total / nilai.length;
}

Penutup: Rangkuman dan Fitur Java 25

Peta Konsep Seluruh Materi

Pertemuan Topik Kata Kunci Utama
1 Pengenalan & instalasi JDK, JRE, JVM, javac, java, Hello World, Scanner
2 Operator & String + - * / %, casting, Math, String, formatted(), text block
3 Percabangan if, else if, ternary, switch expression, pattern matching
4 Perulangan for, while, do-while, break, continue, nested loop
5 Array & Collection int[], int[][], Arrays, ArrayList, List.of
6 Method & Exception static, parameter, return, overloading, rekursi, try-catch

Fitur Java 25 untuk Pemula

Java 25 (LTS) membuat program kecil jauh lebih ringkas, sehingga pemula tidak perlu langsung berhadapan dengan public static void main(String[] args). Dua fitur yang sudah resmi (bukan preview) sejak Java 25:

1. Compact source file dan instance main method: class dan static dapat dihilangkan untuk program sederhana. Simpan sebagai Halo.java:

1
2
3
4
void main() {
    String nama = IO.readln("Siapa namamu? ");
    IO.println("Halo, " + nama + "!");
}

Jalankan dengan:

1
java Halo.java

Class IO (di paket java.lang) menyediakan IO.println(), IO.print(), dan IO.readln() sehingga cukup untuk program belajar tanpa Scanner. Di dalam compact source file, method lain juga dapat ditulis tanpa static:

1
2
3
4
5
6
7
int kuadrat(int n) {
    return n * n;
}

void main() {
    IO.println(kuadrat(12));     // 144
}

2. Module import declarations: satu baris import module mengimpor seluruh paket yang diekspor sebuah modul.

1
2
3
4
5
6
7
8
9
import module java.base;        // List, ArrayList, Scanner, Arrays, Random, dll

public class Main {
    public static void main(String[] args) {
        List<Integer> angka = new ArrayList<>(List.of(5, 3, 8));
        Collections.sort(angka);
        System.out.println(angka);      // [3, 5, 8]
    }
}

Sebagai catatan, pada compact source file seluruh paket dari modul java.base sudah otomatis diimpor, sehingga List, ArrayList, Scanner, dan sejenisnya dapat langsung dipakai tanpa import.

Kedua fitur ini nyaman untuk belajar dan membuat skrip kecil. Pada proyek nyata dan materi lanjutan (OOP, package, Maven/Gradle), kamu tetap akan menulis class secara lengkap, sehingga bentuk klasik public class Main yang kita pelajari tetap penting dipahami.

Perjalanan Selanjutnya

Setelah menguasai dasar ini, topik yang direkomendasikan:

  • Object-Oriented Programming: class, object, constructor, enkapsulasi, inheritance, polymorphism, interface, dan record.
  • Collections Framework: Map (HashMap), Set, Queue, dan Stream API dengan lambda.
  • File I/O dan Exception lanjutan (checked exception, custom exception).
  • Build tools & testing: Maven/Gradle dan JUnit.
  • Pengembangan aplikasi: Spring Boot untuk backend, serta database dengan JDBC/JPA.

Checklist Kemampuan

Centang apakah kamu sudah mampu:

  • [ ] Menginstal JDK dan menjalankan program dari terminal dan IDE.
  • [ ] Menggunakan variabel, tipe data, operator, dan casting dengan benar.
  • [ ] Menulis percabangan if dan switch expression.
  • [ ] Menulis perulangan for, while, dan do-while, termasuk nested loop.
  • [ ] Mengolah array, array 2D, dan ArrayList.
  • [ ] Memecah program menjadi method dengan parameter dan return value.
  • [ ] Menangani input salah dengan try-catch atau hasNextInt().
  • [ ] Membaca pesan error dan memperbaikinya sendiri.

Latihan

Kerjakan latihan berikut untuk mengetes pemahamanmu. Total durasi latihan adalah 60 menit.

No Latihan Estimasi
1 Method Bangun Datar 10 menit
2 Method Prima, Faktorial & Fibonacci 10 menit
3 Overloading & Varargs 5 menit
4 Method pada Array 10 menit
5 Input Aman dengan try-catch 5 menit
6 Proyek Akhir 20 menit
Total 60 menit

Latihan 1: Method Bangun Datar (estimasi 10 menit)

Buat method berikut, lalu panggil dari main dengan menu pilihan bangun:

  • luasPersegiPanjang(double p, double l) dan kelilingPersegiPanjang(double p, double l)
  • luasLingkaran(double r) dan kelilingLingkaran(double r)
  • luasSegitiga(double alas, double tinggi)
  • cetakHasil(String bangun, double luas) bertipe void untuk menampilkan hasil dengan printf 2 angka desimal.

Pastikan method perhitungan mengembalikan nilai dan tidak mencetak sendiri.

Latihan 2: Method Prima, Faktorial & Fibonacci (estimasi 10 menit)

  1. Buat static boolean isPrima(int n), lalu gunakan untuk mencetak semua bilangan prima dari 1 sampai 100.
  2. Buat static long faktorial(int n) secara rekursif dan versi iteratif; bandingkan hasil keduanya untuk n = 1..15.
  3. Buat static int fibonacci(int n) secara rekursif, tampilkan 15 suku pertama.
  4. Buat static boolean isPalindrom(String teks) yang tidak membedakan huruf besar/kecil. Uji dengan "Katak" dan "Java".

Latihan 3: Overloading & Varargs (estimasi 5 menit)

  1. Buat tiga method overloading bernama luas: luas(double sisi) untuk persegi, luas(double panjang, double lebar) untuk persegi panjang, dan luas(String bentuk, double ukuran) yang menghitung luas lingkaran bila bentuk bernilai "lingkaran" (ukuran = jari-jari). Panggil ketiganya dari main.
  2. Buat static double rataRata(double... nilai) yang dapat dipanggil dengan 1 hingga banyak argumen, dan mengembalikan 0 jika tidak ada argumen.

Latihan 4: Method pada Array (estimasi 10 menit)

Buat method berikut dengan parameter int[]:

  • static int cariMaks(int[] data) dan static int cariMin(int[] data)
  • static double hitungRataRata(int[] data)
  • static int[] balikArray(int[] data) yang mengembalikan array baru (tanpa mengubah aslinya)
  • static void urutkan(int[] data) yang mengurutkan array asli (gunakan bubble sort dari Pertemuan 5)
  • static void cetak(int[] data) yang mencetak isi array dengan format [a, b, c]

Buktikan perbedaan: setelah balikArray, array asli tidak berubah; setelah urutkan, array asli berubah. Jelaskan alasannya (pass-by-value dari referensi).

Latihan 5: Input Aman dengan try-catch (estimasi 5 menit)

Buat dua method:

  • static int bacaInt(Scanner input, String pesan, int min, int max) yang terus meminta input sampai pengguna memasukkan bilangan bulat dalam rentang min sampai max.
  • static double bacaDouble(Scanner input, String pesan) dengan perilaku serupa.

Gunakan try-catch untuk InputMismatchException. Pakai method ini pada seluruh program proyek akhir.

Latihan 6: Proyek Akhir, Sistem Manajemen Nilai Mahasiswa (estimasi 20 menit)

Buat aplikasi konsol yang menggabungkan seluruh materi dari Pertemuan 1 sampai 6.

Fitur menu (ditampilkan berulang sampai pengguna memilih keluar):

1
2
3
4
5
6
7
===== SISTEM NILAI MAHASISWA =====
1. Tambah data mahasiswa
2. Tampilkan semua data
3. Cari mahasiswa berdasarkan nama
4. Tampilkan statistik kelas
5. Hapus data mahasiswa
6. Keluar

Ketentuan teknis:

  • Data mahasiswa (nama dan nilai) disimpan menggunakan ArrayList (misalnya dua list paralel: ArrayList<String> dan ArrayList<Integer>).
  • Setiap fitur ditulis sebagai method tersendiri (tambahData, tampilkanData, cariData, tampilkanStatistik, hapusData), dan main hanya berisi menu.
  • Method hitungGrade(int nilai) mengembalikan A/B/C/D/E menggunakan switch expression.
  • Validasi nilai harus 0-100 dan nama tidak boleh kosong atau duplikat; gunakan method input aman dari Latihan 5.
  • Statistik: rata-rata, nilai tertinggi beserta namanya, nilai terendah beserta namanya, dan jumlah mahasiswa per grade.
  • Tampilkan data dalam tabel rapi dengan printf, dan tangani kondisi data kosong dengan pesan yang jelas.
  • Tambahkan komentar singkat dan Javadoc minimal pada tiga method utama.

Rubrik penilaian mandiri:

Aspek Bobot
Program berjalan tanpa error dan menu berulang dengan benar 25%
Pembagian method yang jelas (satu method satu tugas) 25%
Validasi input dan penanganan exception 20%
Penggunaan struktur Java yang tepat (switch expression, ArrayList, loop) 20%
Kerapian kode: penamaan, indentasi, komentar 10%

Tantangan tambahan (jika waktu tersisa):

  • Tambahkan fitur mengurutkan data berdasarkan nilai (menaik/menurun).
  • Tulis ulang versi kecilnya sebagai compact source file Java 25 dengan IO.readln dan IO.println.
  • Simpan data ke file teks dan muat kembali saat program dibuka (siapkan diri untuk materi File I/O).

Selamat! Kamu telah menyelesaikan seluruh materi dasar Java. Terus berlatih, karena kemampuan pemrograman terbentuk dari banyaknya kode yang kamu tulis. ☕