Method Java: Cara Mendefinisikan dan Memanggil Method

Kenapa Method Ada

Method adalah blok kode bernama yang bisa kamu jalankan setiap kali kamu memanggil namanya. Daripada menulis baris yang sama berulang-ulang, kamu menulisnya sekali di dalam method lalu memanggilnya sesering yang kamu butuhkan. Program jadi lebih pendek, lebih mudah dibaca, dan jauh lebih mudah diperbaiki: ubah logikanya di satu tempat, dan setiap pemanggil langsung mendapat perubahannya.

Sebenarnya kamu sudah memanggil method: System.out.println(...) adalah pemanggilan method, begitu juga list.size(). Sekarang kamu akan menulis method sendiri.

Mendeklarasikan dan Memanggil Method

Deklarasi method punya empat bagian: tipe kembalian, nama, sepasang tanda kurung (untuk parameter), dan badan di dalam kurung kurawal. Ini contoh terkecil yang berguna, yaitu method yang mengerjakan sesuatu dan tidak mengembalikan apa pun:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // call it
        printGreeting();   // call it again
    }
}

Perhatikan bagian-bagian dari static void printGreeting():

• static: membuat main bisa memanggilnya langsung tanpa membuat objek (penjelasannya ada di bawah).
• void: method ini tidak mengembalikan nilai.
• printGreeting: nama yang kamu pakai untuk memanggilnya.
• (): tanda kurung kosong berarti method ini tidak menerima input.

Kamu memanggil method dengan menulis namanya diikuti tanda kurung. Dua panggilan di main menjalankan badan method dua kali, jadi sapaannya dicetak dua kali.

Mengembalikan Nilai

Sebagian besar method menghitung sesuatu lalu menyerahkannya kembali dengan return. Tipe kembalian sebelum nama menunjukkan jenis nilai yang keluar, di sini int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) bernilai 25, yang bisa kamu simpan di variabel, cetak, atau pakai di ekspresi yang lebih besar: pemanggilan method menggantikan nilai yang dikembalikannya. Begitu return dijalankan, method berakhir dan alur program kembali ke pemanggil. Kode apa pun setelah return di jalur yang sama tidak pernah dijalankan.

Tipe kembalian dan nilai yang dikembalikan harus cocok: tipe data yang kamu deklarasikan adalah jenis nilai yang dijanjikan method untuk diserahkan. Mendeklarasikan int lalu mencoba return "text"; adalah error kompilasi, karena compiler menegakkan janji itu.

void vs Tipe Kembalian

Pembagiannya sederhana: pakai tipe kembalian sungguhan kalau pemanggil butuh nilai kembali, dan void kalau method hanya melakukan sesuatu (mencetak, menyimpan, memperbarui state).

void logMessage(String msg)   // does work, hands nothing back
int  add(int a, int b)        // computes a value the caller uses

Kesalahan yang sering dilakukan pemula adalah mencoba memakai "hasil" dari method void:

int x = printGreeting();   // compile error: printGreeting() returns void

Tidak ada nilai yang bisa disimpan, jadi kode ini tidak bisa di-compile. Kalau kamu ingin memakai hasil dari method void, itu tanda bahwa method tersebut seharusnya mengembalikan sesuatu.

Method yang Bercabang dan Return Lebih Awal

Kamu bisa melakukan return dari lebih dari satu tempat. Return lebih awal, begitu kamu tahu jawabannya, sering lebih mudah dibaca daripada membungkus semuanya di dalam else:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Karena setiap return langsung keluar dari method, kondisi pertama yang cocok yang menang. Pastikan saja setiap jalur di method yang mengembalikan nilai berakhir dengan return. Kalau ada cabang yang bisa lolos tanpa return, compiler akan protes dengan pesan "missing return statement". return "F"; di akhir contoh ini menangani kasus yang lolos itu.

Arti static di Sini

Mungkin kamu sudah memperhatikan bahwa semua method di atas memakai static. Method static adalah milik class itu sendiri, bukan milik objek tertentu, jadi main (yang juga static) bisa memanggilnya langsung berdasarkan nama. Tanpa static, method itu milik sebuah instance dan kamu butuh objek untuk memanggilnya.

Untuk sekarang, selama kamu menulis program kecil yang logikanya berada di samping main, tandai method bantuanmu dengan static supaya bisa dipanggil dengan cara yang sama. Begitu kamu mulai membuat class dan objek sendiri, kamu juga akan menulis method non-static (method instance), yang dibahas di bab class.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main is static, so it can call doubleIt directly
        System.out.println(doubleIt(21));   // 42
    }
}

Variabel Lokal Tetap di Dalam Method

Variabel yang dideklarasikan di dalam method hanya ada di sana. Variabel itu dibuat saat method berjalan dan hilang saat method selesai, jadi pemanggil tidak pernah melihatnya:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // local to sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // error: total is not visible here
    }
}

total dan i sepenuhnya hidup di dalam sumTo. Satu-satunya yang keluar dari method adalah nilai yang kamu return. Isolasi ini justru fitur: setiap method adalah unit mandiri yang bisa kamu pahami tanpa khawatir variabel sementaranya bocor keluar atau bertabrakan dengan nama di tempat lain.

Berikutnya: Parameter Method

Setiap method di sini tidak menerima input atau hanya menerima satu nilai. Kekuatan sebenarnya datang dari mengirim data masuk, dan Java punya aturan khusus tentang cara argumen dikirim, apa yang terjadi pada objek dibandingkan tipe primitif, dan cara memberi parameter nilai cadangan yang mirip nilai default. Itu topik halaman berikutnya.