Java Academy · Pelajaran

Peraturan Lebihan Muatan Kaedah

Fahami cara Java menyelesaikan kaedah berlebihan muatan dan perangkap kekaburan yang lazim.

Pelajaran 1 daripada 413 langkah

Peraturan Lebihan Muatan Kaedah ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Peraturan Lebihan Kaedah

Lebihan kaedah membolehkan anda mentakrifkan berbilang kaedah dengan nama yang sama tetapi senarai parameter yang berbeza. Java memilih padanan terbaik pada masa kompilasi menggunakan peraturan penyelesaian yang tepat.

Apakah Lebihan Kaedah?

Kaedah yang terlebih muat berkongsi nama tetapi berbeza dari segi bilangan, jenis atau susunan parameter. Jenis pulangan sahaja TIDAK mencukupi untuk melakukan lebihan kaedah.

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)

Penyelesaian: Padanan Paling Khusus

Java memilih kaedah berkenaan yang paling khusus. Pelebaran, pembungkusan automatik dan argumen berubah-ubah dicuba mengikut keutamaan.

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 Automatik

Java lebih mengutamakan pelebaran primitif berbanding pembungkusan automatiknya kepada pembungkus. Hal ini boleh menghasilkan keputusan yang tidak dijangka.

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

Kekaburan Argumen Null

Memberikan nilai kosong kepada kaedah yang terlebih muat boleh menimbulkan kekaburan jika beberapa kaedah menerima jenis rujukan. Tukarkan nilai kosong kepada jenis tertentu untuk menyelesaikannya.

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)

Lebihan Kaedah dengan Pewarisan

Penyelesaian kaedah mengambil kira jenis yang diisytiharkan bagi pemboleh ubah rujukan, bukan jenis semasa masa jalan — ini ialah keputusan pada masa 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

Lebihan Kaedah berbanding Penggantian Kaedah

Lebihan kaedah ialah keputusan pada masa kompilasi (penghantaran statik). Penggantian kaedah ialah keputusan pada masa jalan (penghantaran dinamik) berdasarkan jenis objek sebenar.

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)

Corak Lebihan Kaedah yang Lazim

Penggunaan lebihan kaedah yang lazim dalam antara muka: menyediakan kaedah kemudahan yang menyerahkan tugas kepada 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

Lebihan Kaedah dan Generik

Lebihan kaedah generik memerlukan perhatian — penghapusan jenis boleh menyebabkan dua tandatangan yang kelihatan berbeza menjadi sama selepas 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));

Praktikal: Lebihan Gaya Pembina

Lebihan kaedah lazim digunakan dalam antara muka pembina atau kilang untuk menyediakan penciptaan 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;
    }
}

Perangkap Lebihan Kaedah

Elakkan kesilapan lebihan kaedah yang lazim ini:

Terlalu banyak lebihan untuk operasi yang sama — gunakan pembina sebagai gantinya
Lebihan yang hanya berbeza dari segi susunan parameter — mengelirukan
Pelebaran yang tidak dijangka: jenis nombor bulat mungkin diselesaikan kepada long dan bukannya 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

Semakan Pantas

Jika kaedah terlebih muatan dengan parameter long dan Integer, yang manakah dipilih apabila argumen int dihantar?

Jawab dalam pelajaran interaktif

Ringkasan: Peraturan Pemuatan Berlebihan Kaedah

Perkara utama:

Pemuatan berlebihan berbeza mengikut bilangan, jenis atau susunan parameter — NOT jenis pulangan sahaja
Java menentukan pemilihan kaedah terlebih muatan pada masa kompilasi menggunakan jenis yang diisytiharkan bagi argumen
Pelebaran primitif lebih diutamakan berbanding autoboxing kepada pembalut
Argumen null boleh menyebabkan kekaburan — gunakan cast untuk menyelesaikannya: handle((String) null)
Pemuatan berlebihan berlaku pada masa kompilasi; penggantian berlaku pada masa jalan — kedua-duanya ialah mekanisme yang berbeza
Gunakan kaedah terlebih muatan yang mudah dan mewakilkan tugas kepada kaedah induk dengan semua parameter

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Peraturan Lebihan Muatan Kaedah” percuma?

Ya — teks penuh “Peraturan Lebihan Muatan Kaedah” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Peraturan Lebihan Muatan Kaedah”?

Fahami cara Java menyelesaikan kaedah berlebihan muatan dan perangkap kekaburan yang lazim. Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Peraturan Lebihan Muatan Kaedah” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy