Antara Muka Fungsian di Jawa

Ia mula diperkenalkan dalam java 8. Antara muka berfungsi boleh ditakrifkan sebagai antara muka dengan kaedah abstrak tunggal. Ini bermakna antara muka berfungsi dalam java hanya menyediakan satu fungsi asas sahaja. Walau bagaimanapun, antara muka berfungsi boleh mengandungi kaedah statik dan lalai, sebagai tambahan kepada kaedah abstrak tunggal. java.util.function.Function, java.util.function.Predicate, UnaryOperator, BinaryOperator, Pembekal, Pengguna ialah contoh antara muka berfungsi terbina dalam dalam java.

Mulakan Kursus Pembangunan Perisian Percuma Anda

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

Sintaks Antara Muka Fungsian

Berikut ialah sintaks asas diberikan di bawah:

public interface MyFunctionalInterface(){
// abstract method
public void functionalMethod();
}

Daripada sintaks di atas, kita dapat melihat bahawa antara muka bernama MyFunctionalInterface mengandungi hanya satu kaedah yang tidak dilaksanakan; itulah sebabnya ia boleh dianggap sebagai antara muka berfungsi. Ia juga boleh mengandungi kaedah statik dan lalai seperti yang ditunjukkan di bawah:

public interface MyFunctionalInterface(){
public default void defaultMethod(){
// default method logic goes here
}
public static void staticMethod(){
// static method logic goes here
}
// abstract method
public void functionalMethod();
}

Selain itu, antara muka berfungsi boleh dilaksanakan menggunakan ungkapan Lambda seperti berikut:

MyFunctionalInterface functionalInterface = () ->{
// basic functionality logic goes here
}

Kami juga boleh menggunakan anotasi atau mengisytiharkan antara muka sebagai antara muka berfungsi. Berikut ialah cara antara muka berfungsi boleh diisytiharkan menggunakan anotasi:

MyFunctionalInterface functionalInterface = () ->{
// basic functionality logic goes here
}

@FunctionalInterface telah diperkenalkan dalam java 8 dan digunakan untuk ralat tahap pengkompil sekiranya antara muka melanggar peraturan antara muka berfungsi. Mengisytiharkan antara muka menggunakan anotasi @FunctionalInterface menjadikan antara muka berfungsi dan jika lebih daripada satu kaedah abstrak digunakan, ia akan menghasilkan ralat kompilasi.

Perkara Penting Berkenaan Antara Muka Fungsian

Berikut adalah beberapa perkara penting :

• Hanya satu kaedah abstrak dibenarkan dalam antara muka fungsi. Jika anotasi @FunctionalInterface tidak digunakan dengan antara muka fungsi, maka lebih daripada satu kaedah abstrak boleh diisytiharkan, tetapi dalam kes itu, antara muka itu akan dianggap sebagai tidak berfungsi.
• Penggunaan anotasi @FunctionalInterface adalah pilihan; ia hanya digunakan untuk semakan tahap pengkompil.
• Antara muka berfungsi boleh mengandungi sebarang bilangan kaedah statik dan lalai.
• Kaedah mengatasi daripada kelas induk tidak melanggar peraturan antara muka berfungsi.

Contoh:

@FunctionalInterface
public interface MyFunctionalInterface(){
// abstract method
public void functionalMethod();
@Override
public boolean equals(Object object);
//method overridden from parent class
}

Memandangkan antara muka di atas mengatasi kaedah daripada kelas induk dan tidak mengisytiharkan berbilang kaedah abstrak, ia boleh dianggap sebagai antara muka berfungsi.

Contoh untuk Melaksanakan Antara Muka Fungsian

Kini kita akan melihat contoh kod java yang menunjukkan pengisytiharan dan penggunaan antara muka berfungsi java.

Contoh #1

Dalam contoh ini, kami akan menunjukkan cara antara muka fungsi terbina dalam antara muka java.util.function.function digunakan. Berikut ialah pengisytiharan antara muka Fungsi.

Antara Muka:

package java.util.function;
public interface Function<T,R>{
public <R> apply(T inputparams);
}

Untuk menggunakan antara muka di atas, kami perlu melaksanakannya dalam kelas kami seperti berikut.

Kod:

import java.util.function.*;
public class FunctionalInterfaceDemo implements Function<Integer, Integer>{
@Override
public Integer apply (Integer n){
return n*n;
}
public static void main (String args[]){
FunctionalInterfaceDemo demo = new FunctionalInterfaceDemo ();
Integer sqroot= demo.apply(12);
System.out.println("Square root of 12 is " + sqroot);
}
}

Output:

Contoh #2

Dalam contoh ini, kita akan melihat cara antara muka ini dibuat menggunakan ungkapan lambda.

Kod:

public class FunctionalInterfaceDemo{
public static void main (String args[]){
// creating functional Interface instance
Runnable r = () -> {System.out.println ("Executing Thread........");};
new Thread(r).start();
}
}

Output:

Contoh #3

Dalam contoh ini, kita akan melihat penggunaan pengguna antara muka terbina dalam yang lain untuk mengulangi Senarai.

Kod:

import java.util.function.*;
import java.util.*;
public class FunctionalInterfaceDemo{
public static void main (String args[]){
List<String> list = new ArrayList<String>();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
list.add("Five");
list.add("Six");
// Iterate arraylist using consumer
list.forEach(new Consumer<String>(){
@Override
public void accept(String item){
System.out.println(item);
}
});
}
}

Output:

Kesimpulan

Artikel di atas memberikan pemahaman yang jelas tentang antara muka berfungsi dalam java. Kelebihan utama menggunakan antara muka berfungsi java 8 ialah sokongan untuk ungkapan lambda yang mengalih keluar banyak kod boilerplate, yang seterusnya menghasilkan pembangunan kod yang kecil, cekap dan lebih bersih.

Atas ialah kandungan terperinci Antara Muka Fungsian di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!