Java Academy · Pelajaran

Aturan Overloading Metode

Pahami cara Java menentukan metode yang di-overload dan jebakan ambiguitas yang umum.

Aturan Overloading Metode adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Aturan Pemuatan Berlebih Metode

Pemuatan berlebih metode memungkinkan Anda mendefinisikan beberapa metode dengan nama yang sama, tetapi dengan daftar parameter yang berbeda. Java memilih kecocokan terbaik saat kompilasi menggunakan aturan resolusi yang terperinci.

Apa Itu Pemuatan Berlebih?

Metode yang dimuat berlebih memiliki nama yang sama, tetapi berbeda dalam jumlah, tipe, atau urutan parameter. Tipe pengembalian saja TIDAK cukup untuk membuat pemuatan berlebih.

class Calculator {
    int add(int a, int b)     { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c)   { return a + b + c; }

    // compile error — same signature, different return type only:
    // long add(int a, int b) { return a + b; }
}

Calculator calc = new Calculator();
System.out.println(calc.add(1, 2));       // 3 (int)
System.out.println(calc.add(1.5, 2.5));   // 4.0 (double)
System.out.println(calc.add(1, 2, 3));    // 6 (3-arg)

Resolusi: Kecocokan Paling Spesifik

Java memilih metode berlaku yang paling spesifik. Pelebaran, pembungkusan otomatis, dan argumen variabel dicoba sesuai urutan preferensi.

static void print(int x)    { System.out.println("int: "    + x); }
static void print(long x)   { System.out.println("long: "   + x); }
static void print(Object x) { System.out.println("Object: " + x); }

print(42);       // int: 42 (exact match — most specific)
print(42L);      // long: 42 (exact match)
print(3.14);     // Object: 3.14 (no float match, widening then autoboxing)

Pelebaran Sebelum Pembungkusan Otomatis

Java lebih memilih melebarkan tipe primitif daripada membungkusnya otomatis ke tipe pembungkus. Hal ini dapat menghasilkan hasil yang mengejutkan.

static void display(long n)    { System.out.println("long: " + n); }
static void display(Integer n) { System.out.println("Integer: " + n); }

int x = 100;
display(x); // long: 100 — widens int to long BEFORE autoboxing to Integer
// This surprises many developers!

static void show(Long n)    { System.out.println("Long"); }
static void show(Integer n) { System.out.println("Integer"); }

// show(100); // compile error — ambiguous! Neither is more specific

Ambiguitas Argumen Null

Meneruskan null ke metode yang dimuat berlebih dapat menimbulkan ambiguitas jika beberapa metode menerima tipe referensi. Lakukan cast pada null untuk mengatasinya.

static void handle(String s)  { System.out.println("String: " + s); }
static void handle(Integer i) { System.out.println("Integer: " + i); }
static void handle(Object o)  { System.out.println("Object"); }

handle((String) null);  // String: null (cast resolves ambiguity)
handle((Integer) null); // Integer: null
// handle(null);        // compile error: ambiguous (String vs Integer)

Pemuatan Berlebih dengan Pewarisan

Resolusi metode mempertimbangkan tipe deklarasi variabel referensi, bukan tipe saat waktu berjalan—ini merupakan keputusan saat kompilasi.

class Animal {}
class Dog extends Animal {}

static void greet(Animal a) { System.out.println("Animal"); }
static void greet(Dog d)    { System.out.println("Dog"); }

Animal a = new Dog(); // declared as Animal
greet(a);   // Animal — compile-time type is Animal!

Dog d = new Dog();
greet(d);   // Dog — compile-time type is Dog

Pemuatan Berlebih vs Penimpaan

Pemuatan berlebih merupakan keputusan saat kompilasi (dispat statis). Penimpaan merupakan keputusan saat waktu berjalan (dispat dinamis) berdasarkan tipe objek sebenarnya.

class Base {
    void run() { System.out.println("Base.run"); }
}
class Sub extends Base {
    @Override
    void run() { System.out.println("Sub.run"); } // overriding

    void run(int speed) { System.out.println("Sub.run(" + speed + ")"); } // overloading
}

Base b = new Sub();
b.run();     // Sub.run — override (runtime dispatch)
// b.run(10); // compile error — Base doesn't have run(int)

Pola Umum Pemuatan Berlebih

Penggunaan umum pemuatan berlebih dalam API adalah menyediakan metode praktis yang meneruskan pemanggilan ke versi dengan parameter lengkap.

class Connection {
    void connect(String host, int port, int timeout) {
        System.out.println("Connecting to " + host + ":" + port + " timeout=" + timeout);
    }

    // Convenience overloads
    void connect(String host, int port) {
        connect(host, port, 30); // delegate with default timeout
    }

    void connect(String host) {
        connect(host, 5432); // delegate with default port
    }
}

new Connection().connect("db.example.com");
// Connecting to db.example.com:5432 timeout=30

Pemuatan Berlebih dan Generik

Pemuatan berlebih metode generik memerlukan kehati-hatian—penghapusan tipe dapat membuat dua tanda tangan yang tampaknya berbeda menjadi identik setelah kompilasi.

// Type erasure problem: both methods erase to the same signature!
// static void process(List<String> list) {} // compile error
// static void process(List<Integer> list) {} // duplicate after erasure

// Solutions:
// 1. Use different method names: processStrings / processIntegers
// 2. Use a generic method with bounded type:
static <T extends Number> void processNumbers(List<T> list) {
    list.forEach(n -> System.out.println(n.doubleValue()));
}
processNumbers(List.of(1, 2, 3));
processNumbers(List.of(1.5, 2.5));

Praktik: Pemuatan Berlebih Bergaya Pembangun

Pemuatan berlebih umum digunakan dalam API pembangun atau pabrik untuk menyediakan pembuatan objek yang fleksibel.

class Notification {
    final String title, body;
    final String imageUrl;
    final boolean urgent;

    // Factory overloads for convenience
    static Notification simple(String title, String body) {
        return new Notification(title, body, null, false);
    }
    static Notification urgent(String title, String body) {
        return new Notification(title, body, null, true);
    }
    static Notification withImage(String title, String body, String url) {
        return new Notification(title, body, url, false);
    }
    Notification(String title, String body, String imageUrl, boolean urgent) {
        this.title = title; this.body = body;
        this.imageUrl = imageUrl; this.urgent = urgent;
    }
}

Jebakan Pemuatan Berlebih

Hindari kesalahan umum berikut dalam pemuatan berlebih:

Terlalu banyak overload untuk operasi yang sama—gunakan pembangun sebagai gantinya
Overload yang hanya berbeda dalam urutan parameter—membingungkan
Pelebaran yang mengejutkan: int dapat diresolusikan menjadi long, bukan Integer

// Confusing: order-based overloads
// void save(String name, int age)  {}
// void save(int age, String name)  {} // very confusing!

// Better: use a record/DTO
record UserData(String name, int age) {}
void save(UserData data) {}

// Surprising widening
static void m(long x)   { System.out.println("long"); }
static void m(Integer x){ System.out.println("Integer"); }
int v = 5;
m(v); // long! widening preferred over autoboxing

Pemeriksaan Singkat

Jika sebuah metode memiliki versi dengan parameter long dan Integer, mana yang dipilih saat argumen int diberikan?

Ringkasan: Aturan Overloading Metode

Hal-hal penting:

Overloading dibedakan berdasarkan jumlah, tipe, atau urutan parameter — bukan hanya tipe nilai kembalian
Java menentukan overload pada waktu kompilasi menggunakan tipe yang dideklarasikan untuk argumen
Pelebaran tipe primitif lebih diprioritaskan daripada autoboxing ke tipe pembungkus
Argumen null dapat menyebabkan ambiguitas — gunakan konversi eksplisit untuk mengatasinya: handle((String) null)
Overloading berlangsung pada waktu kompilasi, sedangkan overriding berlangsung saat runtime — keduanya merupakan mekanisme yang berbeda
Gunakan overload kemudahan yang mendelegasikan tugas ke metode utama dengan parameter lengkap

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Aturan Overloading Metode” gratis?

Ya — teks lengkap “Aturan Overloading Metode” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Aturan Overloading Metode”?

Pahami cara Java menentukan metode yang di-overload dan jebakan ambiguitas yang umum. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Aturan Overloading Metode” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy