Java Academy · Pelajaran

Nilai Kembalian dan Pemuatan Berlebih

Pelajari pernyataan return, pengembalian lebih awal, dan pemuatan berlebih metode berdasarkan jumlah serta tipe parameter. Termasuk demo varargs dan pemilihan pemuatan berlebih.

Nilai Kembalian dan Pemuatan Berlebih adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. 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 3 pelajaran total.

Ikhtisar

Tujuan: Menguasai pernyataan pengembalian dan pembebanan berlebih pada metode. Anda akan melihat pengembalian lebih awal (klausa penjaga), pembebanan berlebih berdasarkan jumlah dan tipe, serta demonstrasi singkat argumen variabel.

Pengembalian & Penjaga

Pengembalian mengirimkan nilai kembali ke pemanggil dan mengakhiri metode. Klausa penjaga (pengembalian lebih awal) menjaga kode tetap sederhana dengan menangani kasus khusus terlebih dahulu.

public class Main {
  // Double an integer and return the result
  static int doubleIt(int x) {
    return x * 2;
  }

  // Return a label using a simple early-return pattern (guard clause)
  static String parity(int n) {
    if (n % 2 == 0) {
      return "even";   // early return ends the method here
    }
    return "odd";       // otherwise this path executes
  }

  public static void main(String[] args) {
    System.out.println("doubleIt(7) = " + doubleIt(7));
    System.out.println("parity(10) = " + parity(10));
    System.out.println("parity(11) = " + parity(11));
  }
}

Beberapa Pengembalian

Mengembalikan nilai lebih awal untuk masukan yang tidak valid menghindari penyarangan yang dalam. Di sini, pembagian dengan nol mengembalikan 0 sebagai kebijakan sederhana (nanti Anda akan mempelajari pengecualian).

public class Main {
  // Safe integer division with simple validation
  static int safeDiv(int num, int den) {
    if (den == 0) {
      return 0; // simple policy: return 0 if denominator is zero
    }
    return num / den; // normal path
  }

  public static void main(String[] args) {
    System.out.println("safeDiv(8, 2) = " + safeDiv(8, 2));
    System.out.println("safeDiv(5, 0) = " + safeDiv(5, 0));
  }
}

Pembebanan Berlebih: Jumlah

Pembebanan berlebih berarti menggunakan nama metode yang sama dengan daftar parameter yang berbeda. Mengubah jumlah parameter merupakan pembebanan berlebih yang valid.

public class Main {
  // Overload 1: max of two numbers
  static int max(int a, int b) {
    return (a > b) ? a : b;
  }
  // Overload 2: max of three numbers (different parameter COUNT)
  static int max(int a, int b, int c) {
    int m = (a > b) ? a : b;
    return (m > c) ? m : c;
  }
  public static void main(String[] args) {
    System.out.println("max(3, 9) = " + max(3, 9));
    System.out.println("max(3, 9, 5) = " + max(3, 9, 5));
  }
}

Pembebanan Berlebih: Tipe

Pembebanan berlebih berdasarkan tipe memungkinkan Anda menggunakan kembali sebuah nama untuk operasi yang berkaitan. Argumen numerik campuran dipromosikan ke signatur yang paling spesifik dan cocok.

public class Main {
  // Overload for integers
  static int add(int a, int b) {
    return a + b;
  }
  // Overload for doubles (different parameter TYPES)
  static double add(double a, double b) {
    return a + b;
  }
  public static void main(String[] args) {
    System.out.println("add(2, 3) = " + add(2, 3));           // calls int version
    System.out.println("add(2.5, 3.5) = " + add(2.5, 3.5));   // calls double version
    System.out.println("add(2, 3.5) = " + add(2, 3.5));       // numeric promotion chooses double version
  }
}

Pembebanan Berlebih: Argumen Variabel

Argumen variabel (int...) mengumpulkan nol atau lebih argumen. Resolusi pembebanan berlebih lebih memilih kecocokan tepat yang bukan argumen variabel jika tersedia.

public class Main {
  // Specific overload for two ints
  static int sum(int a, int b) {
    return a + b;
  }
  // Varargs overload for many ints
  static int sum(int... nums) {
    int s = 0;
    for (int i = 0; i < nums.length; i = i + 1) s = s + nums[i];
    return s;
  }
  public static void main(String[] args) {
    // Exact match beats varargs
    System.out.println("sum(4, 5) = " + sum(4, 5));           // picks (int,int)
    System.out.println("sum(1,2,3,4) = " + sum(1, 2, 3, 4));  // uses varargs
  }
}

Pemeriksaan Pembebanan Berlebih

Pemeriksaan singkat: Pasangan manakah yang dapat menjadi pembebanan berlebih yang valid dalam satu kelas?

Ringkasan & Berikutnya

Ringkasan: Anda menggunakan pengembalian dan pengembalian lebih awal, membuat pembebanan berlebih yang valid berdasarkan jumlah dan tipe, serta berlatih menggunakan argumen variabel. Berikutnya: cakupan & masa hidup variabel dan metode.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Nilai Kembalian dan Pemuatan Berlebih” gratis?

Ya — teks lengkap “Nilai Kembalian dan Pemuatan Berlebih” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Nilai Kembalian dan Pemuatan Berlebih”?

Pelajari pernyataan return, pengembalian lebih awal, dan pemuatan berlebih metode berdasarkan jumlah serta tipe parameter. Termasuk demo varargs dan pemilihan pemuatan berlebih. 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 2 dari 3.

Berapa lama pelajaran “Nilai Kembalian dan Pemuatan Berlebih” 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