Coffee break #182. Mga Functional na Interface sa Java

Source: DZone Narito ang isang pangkalahatang-ideya ng mga functional na interface sa Java: layunin, mga halimbawa, lambda expression at isang listahan ng mga paunang natukoy na interface. Bilang isang object-oriented programming language, ang Java dati ay hindi maaaring magkaroon ng mga independiyenteng function dahil lahat maliban sa ilang primitive na uri ng data at pamamaraan sa wika ay umiikot sa mga klase at bagay. Gayunpaman, ipinakilala ng Java 8 ang isang bagong konsepto na tinatawag na Functional Interface at ilang iba pang feature tulad ng Lambda Expressions, Time API, Stream API at iba pa. Ano ang mga functional na interface na ito at kung paano tukuyin ang mga ito? Alamin Natin!

Ano ang isang interface?

Ang interface ay isang hanay ng mga panuntunan na tumutukoy sa pakikipag-ugnayan ng mga elemento ng system. Kilala rin ito bilang outline ng isang klase na naglalaman ng mga abstract na pamamaraan at mga static na constant. Ang isang interface ay maaaring maglaman ng isa o higit pang mga abstract na pamamaraan. Pinapayagan ka ng mga interface na magtakda ng mga kinakailangan para sa mga klase, iyon ay, kung anong mga pamamaraan ang kinakailangan mula sa klase. Sa madaling salita, ang isang interface ay parang isang kontrata na dapat sundin ng bawat implementing class. Narito ang isang halimbawa:

Interface A1
{
void method1();
String method2(String X);
}

Class A1 implements A
{
@Override
public void method1(){}
@Override
public String method2(String X) { return x; }
}

Kung hindi idineklara ng klase na nagpapatupad ng interface ang lahat ng pamamaraan ng interface, hindi tatakbo ang code at bubuo ng error: “ error: A1 is not abstract and not override an abstract method in A1. " (error: A1 is not abstract and not override an abstract method in A1). Bago ang JDK 8, hindi matukoy ng mga interface ang mga pagpapatupad, ngunit ngayon ang mga default na pagpapatupad ay maaaring idagdag para sa mga pamamaraan ng interface. Maaari din nating tukuyin ang mga static at default na pamamaraan, na maaaring tumawag nang walang object sa interface Pangunahing ginagamit ang mga interface upang makamit ang maramihang pamana at maluwag na pagkabit sa code. Ngayong mayroon na tayong malinaw na pag-unawa sa mga interface, tingnan natin kung ano ang functional na interface at kung paano ito gumagana.

Ano ang isang functional na interface?

Ang functional na interface ay kilala rin bilang ang Single Abstract Method (SAM) na interface. Gaya ng ipinahihiwatig ng pangalan, maaari itong magkaroon ng hindi hihigit sa isang abstract na pamamaraan. Ang isang functional na interface ay maaaring magkaroon ng ilang static at default na mga pamamaraan na may pagpapatupad, pati na rin ang isang karagdagang abstract na paraan. Upang markahan ang isang interface bilang functional, ang @FunctionalInterface annotation ay ginagamit . Ito ay kinakailangan upang maiwasan ang maling pagdedeklara ng mga karagdagang pamamaraan. Ang nagpapasikat sa functional na interface ay ang kakayahang gumamit ng mga expression ng lambda upang lumikha ng mga interface nang hindi gumagamit ng anonymous at masalimuot na pagpapatupad ng klase. Ang paggamit ng abstract na keyword sa mga functional na interface ay opsyonal dahil ang mga pamamaraan na tinukoy sa loob ng isang interface ay abstract bilang default.

Ano ang mga expression ng lambda?

Ang lambda expression ay isang hindi pinangalanan o anonymous na pamamaraan na hindi isinasagawa sa sarili nitong, ngunit ginagamit upang ipatupad ang ilang mga paraan ng isang functional na interface. Ito ay tinukoy bilang mga sumusunod:

(parameter list) -> lambda body

Ang arrow operator ( -> ) na nakikita mo sa code ay kilala bilang ang lambda operator. Halimbawa, kung mayroon kaming sumusunod na pamamaraan:

double getGoldenRatioValue() {
return 1.61803;
}

Gamit ang isang lambda expression, maaari naming isulat ito tulad nito:

() -> 1.61803

Tulad ng nakikita mo, ang pamamaraan sa function ng lambda ay walang mga parameter, kaya ang kaliwang bahagi ng pahayag ay walang laman. Dahil tinutukoy ng kanang bahagi ang aksyon, sa halimbawang ito ibabalik nito ang halaga ng golden ratio: 1.61803. Bago ang Java 8, ang pagpapatupad ng mga interface o paglikha ng mga bagay sa loob ng klase ay napakahalaga, ngunit sa Java 8, ang kailangan lang nating gawin ngayon ay magtalaga ng mga expression ng lambda sa mga functional na interface.

Mga halimbawa ng mga functional na interface

Upang lumikha ng mga functional na interface, maaari mong gamitin ang @FunctionalInterface annotation o gamitin ang mga paunang natukoy na functional interface ng Java.

Halimbawa 1

• Una, ita-tag natin ang @FunctionalInterface at gagawa tayo ng interface na tinatawag na MyInterface na tinatawag ng abstract getGoldenRationValue() method .
• Pagkatapos ay gagawa kami ng pangunahing pampublikong klase upang maisagawa ang pamamaraan.
• Upang gumamit ng lambda expression sa isang functional na interface, magdedeklara kami ng reference sa MyInterfaceDemo at pagkatapos ay italaga ang lambda expression sa reference na iyon.
• Sa wakas, ipi-print namin ang golden ratio value gamit ang reference interface.

import java.lang.FunctionalInterface;

// Creation и маркировка функционального интерфейса
@FunctionalInterface

interface MyInterface {
// Это абстрактный метод
double getGoldenRatioValue();
}

public class Main {
public static void main( String[] args ) {

//декларируем ссылку на функциональный интерфейс
MyInterface ref;
//используем Lambda Expression
ref = () -> 1.61803;

System.out.println("Value of Golden Ratio = " + ref.getGoldenRatioValue());
}
}

Konklusyon:

Halimbawa 2

• Sa halimbawang ito, gagamitin namin ang paunang natukoy na interface ng function na ToDoubleFunction , na kumukuha ng T argumento at nagbabalik ng doble bilang output.
• Ang ToDoubleFuntion ay naglalaman ng abstract na pamamaraan na tinatawag na applyasDouble() .
• Panghuli, nai-print namin ang buong haba ng mensahe, kabilang ang mga puwang.

import java.util.function.ToDoubleFunction;
public class MyInterface2 {

public static void main(String[] args) {

ToDoubleFunction<String> length = x -> x.length();

System.out.println(length.applyAsDouble("This is an example of predefined functional interface."));
}
}

Konklusyon:

Listahan ng mga na-preinstall na functional na interface

Ngayong alam na natin kung paano tukuyin ang mga functional na interface, tingnan natin kung gaano karaming mga paunang-natukoy na (built-in) na mga functional na interface ang mayroon. Mayroong 4 na pangunahing uri ng mga functional na interface na maaaring ipatupad sa iba't ibang sitwasyon: Consumer , Predicate , Function at Supplier . Kabilang sa apat na interface na ito, ang Consumer , Function at Predicate ay may mga karagdagang function interface. Narito ang isang listahan ng lahat ng built-in o paunang-natukoy na mga interface sa Java. Tandaan. Ang T, U at R na binanggit sa talahanayan sa ibaba ay kumakatawan sa uri ng unang argumento (T), pangalawang argumento (U) at resulta (R) ng operasyon ayon sa pagkakabanggit.

Isa-isahin natin

Ilang mahalagang takeaways na dapat tandaan mula sa post na ito:

• Gumagana ang interface bilang isang mekanismo ng abstraction.
• Ang isang functional na interface ay maaaring magkaroon ng ilang static at default na mga pamamaraan na may pagpapatupad, pati na rin ang isang karagdagang abstract na paraan.
• Ang mga pamamaraan na tinukoy sa loob ng isang functional na interface ay abstract bilang default, kaya ang paggamit ng abstract na keyword ay hindi na kinakailangan.
• Ang lambda expression ay isang anonymous na paraan na hindi nag-iisa, ngunit ginagamit upang ipatupad ang ilang mga paraan ng isang functional na interface.
• Upang lumikha ng mga functional na interface, maaari mong gamitin ang @FunctionalInterface annotation o gamitin ang mga paunang natukoy na functional interface ng Java.