Rujukan Kaedah Java

Artikel berikut menyediakan garis besar untuk Rujukan Kaedah Java. Dalam JDK 8, ungkapan lambda diperkenalkan untuk mencipta kaedah tanpa nama dalam satu baris untuk melaksanakan satu operasi. Tetapi semasa menulis ungkapan lambda apabila kaedah sedia ada dipanggil, operasi sedemikian dimungkinkan menggunakan Rujukan Kaedah. Ini menjadikan ungkapan lebih padat dan boleh dibaca apabila panggilan kepada kaedah sedia ada wujud. Tambahan pula, dalam skop rujukan kaedah, operator resolusi(:: ) digunakan untuk memisahkan nama kaedah daripada nama kelas.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Jenis Rujukan Kaedah Java

Mari kita lihat keperluan untuk Rujukan kaedah dengan contoh:

Kod:

public class Employee {
public enum Sex {
MALE, FEMALE
}
String name;
LocalDatejoiningDate;
Sex gender;
String emailAddress;
public int getNumberOfYears() {
}
public Calendar getJoiningDate() {
return joiningDate;
}
public static int compareByJoiningDate(Employeea, Employeeb) {
return a.joiningDate.compareTo(b.joiningDate);
}}

Dan jika kita ingin mengisih senarai pekerja mengikut tarikh penyertaan bermakna siapa yang menyertai dahulu, maka kita boleh memanggil kaedah yang diberikan di bawah dalam salah satu subkelas.

Kod:

Person[] rosterAsArray = roster.toArray(new Employee[roster.size()]);
class JoiningDateComparator implements Comparator<Employee> {
public int compare(Employeea, Employeeb) {
return a.getJoiningDate().compareTo(b.getJoiningDate());
}
}

Jadi, kita boleh menulis ungkapan lambda untuk memanggil kaedah di atas sambil mengisih senarai untuk membandingkan tarikh penyertaan 2 Pekerja.

Kod:

Arrays.sort(rosterAsArray,
(a, b) ->Person.compareByAge(a, b)
);

Atau kita boleh memanggil kaedah dengan cara di bawah; kedua-duanya mempunyai maksud yang sama untuk memanggil kaedah untuk setiap pasangan objek dalam tatasusunan.

Kod:

Arrays.sort(rosterAsArray, Person::compareByAge)

Mengikuti empat jenis Rujukan Kaedah wujud dalam JDk 8:

1. Rujukan kepada kaedah statik

Rujukan kepada kaedah statik menggunakan :: operator dikenali sebagai Rujukan kepada Kaedah statik.

Sintaks:

ClassName::MethodName()

Bekerja:

• Di sini kaedah yang dirujuk adalah daripada jenis statik yang bermaksud tiada contoh kelas diperlukan untuk memanggil kaedah ini; sebaliknya, hanya Nama Kelas sudah memadai.
• Oleh itu apabila seseorang menyebutClassName::MethodName dalam ungkapan lambdanya, JRE pergi ke kelas itu untuk mencari kaedah statik dalam kelas yang disebut. Oleh kerana ia adalah panggilan kepada kaedah statik maka tidak boleh disebut di bawah blok bukan statik.

Contoh:

Dalam contoh di bawah, kaedah statik menambah kelas Penambahan dipanggil menggunakan kefungsian kelas dwifungsi dalam pakej java.util, di mana rujukan kaedah ini disimpan dalam objek myObj dan dihantar dengan nilai yang diperlukan untuk diluluskan sebagai hujah.

Kod:

import java.util.function.BiFunction;
class Addition{
public static int add(int a, int b){
return a+b;
}
}
public class HelloWorld {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer>myObj = Addition::add;
int res = myObj.apply(30, 5);
System.out.println("Sum of given number is: "+res);
}
}

Output:

2. Rujukan kepada kaedah contoh bagi objek tertentu

Sintaks:

object::methodName()

Bekerja:

• Dalam jenis rujukan ini, seseorang menggunakan objek kelas untuk merujuk kepada salah satu kaedah contohnya. Di sini JRE menyemak sama ada hujah yang diluluskan adalah jenis yang sama seperti yang dinyatakan dalam pengisytiharan kaedah.
• Ini membantu menulis ungkapan lambda menggunakan kaedah contoh kelas.

Contoh:

Dalam contoh di bawah, kaedah showName kelas HelloWorld dipanggil menggunakan kaedah rujukan kepada kaedah contoh.

Kod:

interface MyInterface{
void display();
}
public class HelloWorld {
public void showName(){
System.out.println("Call to method ShowName");
}
public static void main(String[] args) {
HelloWorld obj = new HelloWorld();
MyInterface ref = obj::showName;
ref.display();
}
}

Output:

3. Rujukan kepada kaedah contoh objek arbitrari jenis tertentu

Sintaks:

ClassName :: instanceMethodName()

Bekerja:

• Ini adalah jenis rujukan yang sama seperti yang diberikan di atas, perbezaan terletak di sini bahawa objek yang dirujuk di sini sentiasa berubah, yang bermaksud banyak objek memanggil kaedah yang sama tetapi jenis yang sama menggunakan rujukan kaedah.

Contoh: Dalam contoh di bawah, kami memanggil kaedah compareToIgnoreCase untuk semua rentetan yang disimpan dalam tatasusunan. Oleh itu, bukannya melepasi objek berbeza satu demi satu, ini berlaku dalam satu pernyataan menggunakan senarai.

Kod:

import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
String[] empArray = { "John", "Jack", "Aditya", "Vishal", "Saurabh", "Amanda", "Daniel"};
Arrays.sort(empArray, String::compareToIgnoreCase);
System.out.println("Sorted list of names of Employees \n");
for(String str: empArray){
System.out.println(str);
}
}
}

Output:

4. Rujukan kepada pembina

Sintaks:

myFunc(roster, HashSet<MyClass>::new);

Bekerja:

• Panggilan rujukan ini juga dibuat untuk memanggil pembina kelas.
• Untuk ini, kata kunci 'baharu' sedang digunakan dalam ungkapan lambda, dan dengan itu JRE membuat kesimpulan untuk memanggil pembina kelas tertentu itu.

Mari kita ambil contoh ungkapan lambda yang mengandungi panggilan ke kaedah di bawah dan memerlukan pembina baharu HashSet untuk dihantar.

Kod:

publicstatic<T, MYSRCextends Collection<T>, MYDESTextends Collection<T>>
MYDEST MyMethod(
MYSRC src,
Supplier< MYDEST>dest) {
MYDEST res = collectionFactory.get();
for (T t : src)
{res.add(t);
}
returnres;
}

Kemudian ungkapan lambda akan menjadi seperti:

Kod:

Set<myClass>rosterSet = MyMethod(roster, HashSet::new);

Di sini JRE secara automatik membuat kesimpulan bahawa argumen yang diluluskan mengandungi objek jenis myClass  atau sama ada kita boleh menggunakan ungkapan lambda di bawah untuk

Set<myClass>rosterSet = transferElements(roster, HashSet<myClass>::new);

Example: In the below example, a constructor of a firstReference class is being called using ‘new’ operator and stored in a reference variable ‘inObj’. This reference variable is then used to refer to the instance methods of this class.

Code:

@FunctionalInterface
interface firstInterface{
firstReference show(String say);
}
class firstReference{
public firstReference(String say){
System.out.print(say);
}
}
public class HelloWorld {
public static void main(String[] args) {
//Method reference to a constructor
firstInterface inObj = firstReference::new;
inObj.show("Let’s begin learning Contructor type method reference");
}
}

Output:

Conclusion

Method Reference is a way to make a call to an existing method in lambda expressions being used in the application. This feature has been introduced with JDK 1.8 to make lambda expressions more compact and reuse the existing code. There are four ways to make calls to the methods of the class names as shown above.

Atas ialah kandungan terperinci Rujukan Kaedah Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!