Parameter Method Java: Argumen, Pass-by-Value, dan Return

Parameter Membuat Method Bisa Menerima Input

Method yang selalu melakukan hal yang sama itu terbatas. Parameter adalah input yang kamu deklarasikan di dalam tanda kurung method, sehingga method yang sama bisa bekerja dengan nilai yang berbeda setiap kali dipanggil.

Kamu menulis setiap parameter dengan tipe dan nama. Di dalam badan method, parameter berperilaku seperti variabel lokal biasa yang sudah berisi apa pun yang dikirim pemanggil.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name adalah parameternya. "Sam" dan "Alex" adalah argumennya, yaitu nilai konkret yang diberikan saat pemanggilan. Satu definisi method, dua output yang berbeda.

Parameter vs Argumen

Dua kata ini sering dipakai bergantian, tetapi perbedaannya layak diingat dengan jelas:

• Parameter adalah tempat penampung di deklarasi: String name.
• Argumen adalah nilai yang benar-benar kamu kirim: "Sam".

Jadi void greet(String name) mendeklarasikan parameter, dan greet("Sam") mengirim argumen. Kalau seseorang berkata "method ini menerima dua parameter", yang dimaksud adalah deklarasinya; "saya mengirim dua argumen" berarti panggilannya.

Banyak Parameter

Pisahkan parameter dengan koma, dan beri masing-masing tipenya sendiri. Kamu tidak bisa memakai satu tipe untuk dua parameter sekaligus seperti yang bisa kamu lakukan di deklarasi variabel:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Argumen dicocokkan dengan parameter murni berdasarkan posisi, bukan nama. describe("Sam", 30, true) berjalan karena urutannya sesuai dengan (String name, int age, boolean active). Kalau kamu menukar dua argumen yang tipenya kompatibel, hasilnya bug logika yang diam-diam, bukan error kompilasi. Jadi urutan itu penting.

Kesalahan yang umum adalah menulis int add(int a, b). Setiap parameter butuh tipenya sendiri: int add(int a, int b).

Mengembalikan Nilai

Parameter adalah jalan data masuk; nilai kembalian adalah jalan hasil keluar. Deklarasikan tipe kembalian sebelum nama method, lalu pakai return untuk menyerahkan nilai ke pemanggil:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 forces floating-point division
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Tipe kembalian (double) harus sesuai dengan apa yang benar-benar kamu return. Method yang dideklarasikan void tidak mengembalikan apa pun. Method itu tetap bisa memakai return; saja untuk keluar lebih awal, tetapi tidak bisa mengembalikan nilai. Begitu return dijalankan, method berakhir dan alur program kembali ke tempat pemanggilannya.

Java Itu Pass-by-Value

Hal ini membingungkan hampir semua orang di awal. Saat kamu mengirim argumen, Java menyalin nilainya ke parameter. Untuk tipe primitif, artinya method mendapat salinannya sendiri, jadi mengubah parameter tidak pernah menyentuh variabel milik pemanggil:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // changes only this local copy
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // still 5
    }
}

x tetap 5. Method itu mengubah salinan angkanya sendiri, bukan aslinya.

Mengirim Objek: Tetap by Value, tapi Perhatikan Referensinya

Objek terasa seperti pengecualian, padahal bukan. Yang disalin adalah referensinya (penunjuk ke objek), bukan objeknya. Jadi method menunjuk ke objek yang sama dan bisa mengubah isinya. Itulah sebabnya menambah elemen ke ArrayList yang dipakai bersama di dalam method terlihat oleh pemanggil:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // mutates the shared object - visible to caller
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reassigns the local copy only - NOT visible
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // still [a, b, new] - reassignment didn't escape
    }
}

Dua hasil yang berbeda, satu aturan. addItem mengikuti referensi dan mengubah list yang asli, jadi pemanggil melihat new muncul. replace mengisi ulang parameternya dengan list yang benar-benar baru, tetapi itu hanya mengarahkan ulang salinan lokal dari referensinya, jadi list milik pemanggil tidak tersentuh. Intinya: kamu bisa mengubah objek lewat parameter, tetapi kamu tidak pernah bisa membuat variabel milik pemanggil menunjuk ke tempat lain.

Berikutnya: Method Overloading

Sekarang kamu tahu cara memberi method input yang tepat sesuai kebutuhannya. Tapi bagaimana kalau kamu ingin satu nama method menerima kumpulan parameter yang berbeda, misalnya print(int) dan print(String)? Itulah method overloading, dan itu topik halaman berikutnya.