Method di Java: Deklarasi, Parameter, dan Return

Method adalah blok kode yang diberi nama dan bisa dipanggil berkali-kali dari bagian lain program. Bayangkan membangun sistem seperti aplikasi pemesanan — kamu akan membuat method hitungTotal(), validasiPembayaran(), kirimNotifikasi() yang bisa digunakan berulang kali tanpa menulis kode yang sama berkali-kali. Dengan method, kode menjadi lebih terorganisir, mudah dipelihara, dan tidak DRY (Don’t Repeat Yourself).

Anatomi Method di Java

// Syntax lengkap
[modifier] [static] tipeReturn namaMethod([tipe param, ...]) {
    // isi method
    return nilai; // wajib jika tipeReturn bukan void
}

Method sederhana:

public class ContohMethod {

    // Method dengan dua parameter dan return value
    static int tambah(int a, int b) {
        return a + b;
    }

    // Method void — tidak mengembalikan nilai
    static void sapa(String nama) {
        System.out.println("Halo, " + nama + "!");
    }

    public static void main(String[] args) {
        int hasil = tambah(5, 3);
        System.out.println("5 + 3 = " + hasil);
        // Output: 5 + 3 = 8

        sapa("Budi");
        // Output: Halo, Budi!

        // Bisa juga langsung dalam println
        System.out.println("10 + 20 = " + tambah(10, 20));
        // Output: 10 + 20 = 30
    }
}

Method dengan Berbagai Tipe Return

// Return boolean
static boolean adalahGenap(int n) {
    return n % 2 == 0;
}

// Return String
static String kategoriNilai(int nilai) {
    if (nilai >= 90) return "A";
    if (nilai >= 80) return "B";
    if (nilai >= 70) return "C";
    if (nilai >= 60) return "D";
    return "E";
}

// Return double
static double hitungLingkaran(double jari_jari) {
    return Math.PI * jari_jari * jari_jari;
}

System.out.println(adalahGenap(10));        // Output: true
System.out.println(kategoriNilai(85));      // Output: B
System.out.printf("Luas: %.2f%n", hitungLingkaran(7));
// Output: Luas: 153.94

Method Overloading

Java memungkinkan beberapa method dengan nama sama selama daftar parameternya berbeda:

// Overloading untuk cetak berbagai tipe
static void cetak(int angka) {
    System.out.println("int: " + angka);
}

static void cetak(double desimal) {
    System.out.println("double: " + desimal);
}

static void cetak(String teks) {
    System.out.println("String: " + teks);
}

static void cetak(int a, int b) {
    System.out.println("Dua int: " + a + " dan " + b);
}

cetak(42);        // Output: int: 42
cetak(3.14);      // Output: double: 3.14
cetak("Halo");    // Output: String: Halo
cetak(10, 20);    // Output: Dua int: 10 dan 20

Varargs — Jumlah Parameter Fleksibel

Varargs memungkinkan method menerima jumlah argumen yang tidak tetap:

// ... berarti "nol atau lebih parameter bertipe int"
static int jumlahkan(int... angka) {
    int total = 0;
    for (int n : angka) {
        total += n;
    }
    return total;
}

static double rata2(double... nilai) {
    if (nilai.length == 0) return 0;
    double total = 0;
    for (double n : nilai) total += n;
    return total / nilai.length;
}

System.out.println(jumlahkan(1, 2, 3));          // Output: 6
System.out.println(jumlahkan(10, 20, 30, 40));   // Output: 100
System.out.println(jumlahkan());                  // Output: 0

System.out.printf("Rata-rata: %.1f%n", rata2(85, 90, 78, 92));
// Output: Rata-rata: 86.3

Pass by Value di Java

Di Java, semua argumen diteruskan secara pass by value — termasuk objek. Memahami ini penting untuk menghindari bug.

Primitif — Pass by Value (Salinan)

static void coba_ubah(int x) {
    x = 999; // hanya mengubah salinan lokal
}

int angka = 42;
coba_ubah(angka);
System.out.println(angka); // Output: 42 (tidak berubah!)

Objek — Referensi Diteruskan (tapi tetap by value)

import java.util.ArrayList;

static void tambahItem(ArrayList<String> list) {
    list.add("Item Baru"); // Mengubah objek yang direferensikan ✅
}

static void ganti_list(ArrayList<String> list) {
    list = new ArrayList<>(); // Hanya mengganti referensi lokal, tidak efek ❌
    list.add("Tidak efek");
}

ArrayList<String> daftar = new ArrayList<>();
daftar.add("Item Awal");

tambahItem(daftar);
System.out.println(daftar); // Output: [Item Awal, Item Baru]

ganti_list(daftar);
System.out.println(daftar); // Output: [Item Awal, Item Baru] (tidak berubah)

Rekursi — Method yang Memanggil Dirinya Sendiri

// Faktorial: n! = n × (n-1) × ... × 1
static long faktorial(int n) {
    if (n <= 1) return 1;         // Base case
    return n * faktorial(n - 1);  // Recursive case
}

// Fibonacci: 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);
}

System.out.println("5! = " + faktorial(5));   // Output: 5! = 120
System.out.println("7! = " + faktorial(7));   // Output: 7! = 5040

for (int i = 0; i <= 8; i++) {
    System.out.print(fibonacci(i) + " ");
}
System.out.println();
// Output: 0 1 1 2 3 5 8 13 21

Contoh Nyata: Sistem Konversi Suhu

public class KonversiSuhu {

    static double celsiusKeFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }

    static double fahrenheitKeCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5.0 / 9.0;
    }

    static double celsiusKeKelvin(double celsius) {
        return celsius + 273.15;
    }

    static void tampilkanKonversi(double celsius) {
        System.out.printf("%.1f°C = %.1f°F = %.2fK%n",
            celsius,
            celsiusKeFahrenheit(celsius),
            celsiusKeKelvin(celsius)
        );
    }

    public static void main(String[] args) {
        tampilkanKonversi(0);    // Output: 0.0°C = 32.0°F = 273.15K
        tampilkanKonversi(100);  // Output: 100.0°C = 212.0°F = 373.15K
        tampilkanKonversi(37);   // Output: 37.0°C = 98.6°F = 310.15K
    }
}

Pertanyaan yang Sering Diajukan

Apa itu static pada method dan kapan membutuhkannya?

Method static bisa dipanggil langsung melalui nama class tanpa membuat objek. Method non-static membutuhkan instance (objek). Dalam class yang hanya berisi main(), semua method pembantu harus static karena main sendiri adalah static. Saat belajar OOP nanti, kamu akan lebih sering menggunakan non-static method.

Apa itu method overloading dan apakah membingungkan?

Overloading adalah fitur yang memungkinkan nama method yang sama untuk berbagai tipe parameter. Compiler secara otomatis memilih versi yang tepat berdasarkan argumen yang diberikan. Ini sangat berguna dan umum di Java — misalnya System.out.println() sendiri sudah di-overload untuk int, double, String, dll.

Apa itu varargs dan kapan menggunakannya?

Varargs (tipe... namaParam) memungkinkan method menerima jumlah argumen yang tidak tentu. Di balik layar, Java mengemas argumen-argumen tersebut ke dalam array. Gunakan varargs untuk method utilitas seperti sum(), max(), atau logger yang menerima banyak nilai. Varargs harus selalu menjadi parameter terakhir dalam daftar parameter.

Apakah Java menggunakan pass by reference seperti C++?

Tidak! Java selalu menggunakan pass by value. Untuk tipe primitif, nilai disalin. Untuk objek, referensi (pointer) ke objek disalin — bukan objek itu sendiri. Ini berarti kamu bisa mengubah isi objek dalam method, tapi tidak bisa mengganti referensi objek itu dari dalam method.

Kesimpulan

Ringkasan konsep method di Java:

Artikel sebelumnya: Percabangan dan Perulangan di Java — cara membuat keputusan dan loop di Java.

Kamu sudah menyelesaikan fondasi Java! Langkah selanjutnya adalah mempelajari Object-Oriented Programming (OOP) di Java — konsep class, object, inheritance, dan encapsulation yang menjadi inti dari bahasa Java.