Java Academy · Pelajaran

Rujukan Kaedah Statik

Gantikan lambda yang memanggil kaedah statik dengan rujukan ClassName::methodName.

Pelajaran 1 daripada 413 langkah

Rujukan Kaedah Statik 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.

Apakah Rujukan Kaedah?

Rujukan kaedah ialah lambda ringkas yang menyerahkan tugas kepada kaedah sedia ada. Apabila lambda hanya memanggil satu kaedah, rujukan kaedah lebih kemas dan mudah dibaca.

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

List<String> names = List.of("Alice", "Bob", "Carol");

// Lambda:
names.forEach(s -> System.out.println(s));

// Equivalent method reference:
names.forEach(System.out::println);

Sintaks Rujukan Kaedah Statik

Rujukan kaedah statik berbentuk ClassName::staticMethodName. Ia boleh digunakan di mana-mana antara muka fungsian menjangkakan kaedah dengan tandatangan yang sama.

import java.util.stream.*;

// Integer.parseInt(String) matches Function<String, Integer>
List<String> strs = List.of("1","2","3","4","5");
List<Integer> nums = strs.stream()
    .map(Integer::parseInt)  // replaces s -> Integer.parseInt(s)
    .collect(Collectors.toList());
System.out.println(nums); // [1, 2, 3, 4, 5]

Math.abs sebagai Rujukan Kaedah

Kaedah statik daripada kelas utiliti seperti Math boleh dirujuk secara langsung:

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

List<Integer> values = List.of(-3, 5, -1, 8, -4);
List<Integer> abs = values.stream()
    .map(Math::abs)  // replaces v -> Math.abs(v)
    .collect(Collectors.toList());
System.out.println(abs); // [3, 5, 1, 8, 4]

Rujukan Kaedah Statik dengan Predikat

Kaedah statik yang sepadan dengan pulangan boolean boleh berfungsi sebagai Predicate:

import java.util.stream.*;

// String.isEmpty() is an instance method, but we can use a static helper
// Objects.isNull matches Predicate<Object>
List<String> mixed = Arrays.asList("hello", null, "world", null);
long nullCount = mixed.stream()
    .filter(Objects::isNull)
    .count();
System.out.println(nullCount); // 2

long nonNull = mixed.stream()
    .filter(Objects::nonNull)
    .count();
System.out.println(nonNull); // 2

Rujukan Statik Comparator

Kaedah statik yang sepadan dengan Comparator juga boleh dirujuk:

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

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

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

Kaedah Bantuan Statik Tersuai

Takrifkan kaedah utiliti statik dan rujuknya secara langsung:

class Validator {
    static boolean isPositive(int n) { return n > 0; }
    static String toLabel(int n) { return n > 0 ? "POS" : "NEG"; }
}

List<Integer> nums = List.of(-2, 3, -1, 5, 0);

List<Integer> positive = nums.stream()
    .filter(Validator::isPositive)
    .collect(Collectors.toList());
System.out.println(positive); // [3, 5]

List<String> labels = nums.stream()
    .map(Validator::toLabel)
    .collect(Collectors.toList());

BiFunction dengan Kaedah Statik

Kaedah statik yang menerima dua parameter boleh sepadan dengan BiFunction<T,U,R>:

import java.util.function.*;

// Math.max(int,int) → BiFunction... but needs IntBinaryOperator
java.util.function.IntBinaryOperator maxOp = Math::max;
System.out.println(maxOp.applyAsInt(7, 3)); // 7

// String.format as BiFunction? Only works if signature matches:
// Integer.sum(int,int) → IntBinaryOperator
java.util.function.IntBinaryOperator sum = Integer::sum;
System.out.println(sum.applyAsInt(10, 20)); // 30

Mengisih dengan Comparator.comparing + rujukan statik

Gabungkan Comparator.comparing dengan rujukan kaedah untuk pengisihan yang kemas:

record Person(String name, int age) {}
List<Person> people = List.of(
    new Person("Charlie",30), new Person("Alice",25), new Person("Bob",35)
);

people.stream()
    .sorted(Comparator.comparing(Person::name))
    .forEach(p -> System.out.println(p.name()));
// Alice, Bob, Charlie

Bila Menggunakan Rujukan Kaedah Statik

Gunakan rujukan kaedah statik apabila:

Badan lambda ialah satu panggilan kaedah statik
Tiada transformasi argumen diperlukan
Tandatangan kaedah sepadan dengan antara muka fungsian

Jika anda perlu mengubah argumen atau menambah logik, gunakan lambda.

Perbandingan Kebolehbacaan

Perbandingan bersebelahan antara gaya lambda dengan gaya rujukan kaedah:

// Lambda style
Stream.of("1","2","3").map(s -> Integer.parseInt(s));
Stream.of(1,-2,3).filter(n -> n > 0);
Stream.of(-5,2,-1).map(n -> Math.abs(n));

// Method reference style
Stream.of("1","2","3").map(Integer::parseInt);
Stream.of(1,-2,3).filter(Validator::isPositive);
Stream.of(-5,2,-1).map(Math::abs);

Perangkap Biasa: Tandatangan Salah

Rujukan kaedah hanya berfungsi jika tandatangannya sepadan tepat dengan kaedah abstrak antara muka fungsian. Jika jenis atau bilangan argumen berbeza, gunakan pembungkus lambda.

// Math.pow(double, double) needs two args — can't use as Function<Double, Double>
// This won't compile:
// Function<Double, Double> square = Math::pow; // ERROR

// Fix with lambda:
Function<Double, Double> square = n -> Math.pow(n, 2);
System.out.println(square.apply(5.0)); // 25.0

Semakan Ringkas

Manakah antara berikut ialah rujukan kaedah statik yang sah dan berfungsi sebagai Predicate<Object>?

Jawab dalam pelajaran interaktif

Ringkasan: Rujukan Kaedah Statik

Perkara utama:

Sintaks: ClassName::staticMethodName
Menggantikan lambda yang menyerahkan tugas kepada satu kaedah statik
Tandatangan kaedah mestilah sepadan dengan kaedah abstrak antara muka fungsian
Berfungsi dengan predikat, Function, pengguna, Comparator dan lain-lain
Gunakan lambda apabila transformasi argumen atau logik tambahan diperlukan

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 Statik” percuma?

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

Gantikan lambda yang memanggil kaedah statik dengan rujukan ClassName::methodName. 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 “Rujukan Kaedah Statik” 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