Java Academy · Pelajaran

Rujukan Kaedah Tika Sembarangan

Rujuk kaedah tika tanpa menentukan penerima — banyak digunakan dengan operasi Stream.

Pelajaran 3 daripada 413 langkah

Rujukan Kaedah Tika Sembarangan ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 3 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.

Apakah Rujukan Instans Sebarang?

Rujukan kaedah instans sebarang menggunakan ClassName::instanceMethod. Di sini, argumen pertama antara muka berfungsi bertindak sebagai penerima — setiap elemen menjadi objek yang kaedahnya dipanggil.

import java.util.*;
import java.util.stream.*;

List<String> names = List.of("alice","bob","carol");

// String::toUpperCase — receiver is each list element
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(upper); // [ALICE, BOB, CAROL]

Cara Penerima Ditentukan

Bagi rujukan instans sebarang Type::method, parameter pertama antara muka berfungsi menjadi this (penerima):

// String::length matches Function<String, Integer>
// Equivalent to: s -> s.length()
Function<String, Integer> len = String::length;
System.out.println(len.apply("Java")); // 4

// String::isEmpty matches Predicate<String>
// Equivalent to: s -> s.isEmpty()
Predicate<String> isEmpty = String::isEmpty;
System.out.println(isEmpty.test(""));   // true

Banyak Digunakan dengan Operasi Strim

Rujukan instans sebarang ialah jenis yang paling biasa dalam aliran pemprosesan strim:

List<String> words = List.of("Hello","","World","","Java");

// filter with String::isEmpty
long empty = words.stream().filter(String::isEmpty).count();
System.out.println(empty); // 2

// map with String::toLowerCase
words.stream()
     .filter(s -> !s.isEmpty())
     .map(String::toLowerCase)
     .forEach(System.out::println);

Gaya BiFunction dengan Kaedah Dua Argumen

Kaedah dua argumen pada sesuatu jenis sepadan dengan BiFunction<T, U, R>, dengan T ialah penerima dan U ialah argumen:

import java.util.function.*;

// String::startsWith → BiPredicate<String, String>
// receiver=first arg, argument=second arg
BiPredicate<String, String> starts = String::startsWith;
System.out.println(starts.test("JavaStream", "Java")); // true
System.out.println(starts.test("Python", "Java"));      // false

Pembanding dengan Instans Sebarang

String::compareTo sepadan dengan Comparator<String> — dua argumen pembanding menjadi penerima dan parameter:

List<String> words = List.of("banana","apple","cherry");

List<String> sorted = words.stream()
    .sorted(String::compareTo)
    .collect(Collectors.toList());
System.out.println(sorted); // [apple, banana, cherry]

Instans Sebarang Kelas Tersuai

Berfungsi dengan kaedah instans mana-mana kelas, bukan jenis JDK sahaja:

record Product(String name, double price) {
    boolean isExpensive() { return price > 50; }
    String label() { return name + " ($" + price + ")"; }
}

List<Product> products = List.of(
    new Product("Widget", 9.99),
    new Product("Gadget", 99.99),
    new Product("Donut", 1.50)
);

products.stream()
    .filter(Product::isExpensive)
    .map(Product::label)
    .forEach(System.out::println); // Gadget ($99.99)

Perbezaan daripada Instans Tertentu

Perbezaan utama:

Tertentu: obj::method — obj sentiasa menjadi penerima
Sebarang: Type::method — setiap elemen IS penerima

String fixed = "prefix";
// Specific instance: fixed is always the receiver
Predicate<String> startsFixed = fixed::startsWith; // always checks 'prefix'.startsWith(arg)

// Arbitrary instance: each element is the receiver
Predicate<String> isEmpty = String::isEmpty; // each element.isEmpty()

Rujukan Kaedah dalam Pengumpul

Rujukan instans sebarang bergabung secara semula jadi dengan pengumpul:

List<String> items = List.of("  hello "," world ","  java  ");
List<String> trimmed = items.stream()
    .map(String::trim)
    .collect(Collectors.toList());
System.out.println(trimmed); // [hello, world, java]

Merantai Rujukan Kaedah

Rujukan kaedah boleh dirantai dengan andThen/compose pada fungsi:

Function<String, String> pipeline =
    ((Function<String, String>) String::trim)
        .andThen(String::toUpperCase);

System.out.println(pipeline.apply("  hello world  "));
// HELLO WORLD

Perangkap: Kaedah Terlebih Beban

Apabila sesuatu kaedah mempunyai beberapa beban, pengompil mesti menentukan beban mana yang sepadan dengan antara muka berfungsi. Jika terdapat kekaburan, ralat kompilasi berlaku — gunakan lambda untuk menjelaskannya:

// println is overloaded — which one?
// Consumer<String> c = System.out::println; // OK — infers println(String)
// Consumer<Object> c2 = System.out::println; // OK

// But if ambiguous:
// Function<Object,?> fn = System.out::println; // Error — println doesn't return a value

Prestasi

Rujukan kaedah dan lambda dikompilkan kepada bait kod yang sama (melalui invokedynamic). Tiada perbezaan prestasi — pilih yang lebih mudah dibaca. Kebanyakan panduan gaya mengutamakan rujukan kaedah apabila rujukan tersebut menyatakan niat dengan jelas.

Semakan Pantas

Apakah yang diwakili oleh String::toUpperCase apabila digunakan dengan .map()?

Jawab dalam pelajaran interaktif

Imbas Kembali: Rujukan Kaedah Instans Sebarang

Perkara penting:

Sintaks: ClassName::instanceMethod — setiap elemen ialah penerima
Sepadan dengan antara muka berfungsi yang penerimanya ialah parameter pertama
Paling biasa dalam .map(), .filter(), .sorted() dan .forEach()
Kaedah dua argumen → BiFunction/BiPredicate dengan elemen sebagai penerima
Tiada perbezaan prestasi berbanding lambda — pilih berdasarkan kebolehbacaan

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 “Rujukan Kaedah Tika Sembarangan” percuma?

Ya — teks penuh “Rujukan Kaedah Tika Sembarangan” 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 “Rujukan Kaedah Tika Sembarangan”?

Rujuk kaedah tika tanpa menentukan penerima — banyak digunakan dengan operasi Stream. 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 3 daripada 4.

Berapa lamakah pelajaran “Rujukan Kaedah Tika Sembarangan” 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