ที่มา: DZone นี่คือภาพรวมของอินเทอร์เฟซการทำงานใน Java: วัตถุประสงค์ ตัวอย่าง นิพจน์แลมบ์ดา และรายการอินเทอร์เฟซที่กำหนดไว้ล่วงหน้า
เนื่องจากเป็นภาษาการเขียนโปรแกรมเชิงวัตถุ ก่อนหน้านี้ Java ไม่สามารถมีฟังก์ชันอิสระได้ เนื่องจากทุกอย่างยกเว้นประเภทข้อมูลพื้นฐานและวิธีการในภาษานั้นหมุนรอบคลาสและอ็อบเจ็กต์ อย่างไรก็ตาม Java 8 ได้เปิดตัวแนวคิดใหม่ที่เรียกว่า Functional Interface และยังมีฟีเจอร์อื่นๆ เช่น Lambda Expressions, Time API, Stream API และอื่นๆ อินเทอร์เฟซการทำงานเหล่านี้คืออะไรและจะกำหนดได้อย่างไร มาหาคำตอบกัน!

อินเทอร์เฟซคืออะไร?
อินเทอร์เฟซคือชุดของกฎที่กำหนดการโต้ตอบขององค์ประกอบระบบ เป็นที่รู้จักกันว่าเป็นโครงร่างของคลาสที่มีวิธีการเชิงนามธรรมและค่าคงที่แบบคงที่ อินเทอร์เฟซอาจมีวิธีนามธรรมตั้งแต่หนึ่งวิธีขึ้นไป อินเทอร์เฟซยังช่วยให้คุณกำหนดข้อกำหนดสำหรับคลาสได้ นั่นคือวิธีการใดที่จำเป็นสำหรับคลาส พูดง่ายๆ ก็คือ อินเทอร์เฟซเปรียบเสมือนสัญญาที่ต้องปฏิบัติตามโดยทุกคลาสการใช้งาน นี่คือตัวอย่าง:Interface A1
{
void method1();
String method2(String X);
}
Class A1 implements A
{
@Override
public void method1(){}
@Override
public String method2(String X) { return x; }
}
หากคลาสที่ใช้อินเทอร์เฟซไม่ประกาศวิธีการทั้งหมดของอินเทอร์เฟซ โค้ดจะไม่ทำงานและจะสร้างข้อผิดพลาด: “ ข้อผิดพลาด: A1 ไม่ใช่นามธรรมและไม่ได้แทนที่วิธีนามธรรมใน A1 " (ข้อผิดพลาด: A1 ไม่ใช่นามธรรมและไม่ได้แทนที่วิธีนามธรรมใน A1) ก่อน JDK 8 อินเทอร์เฟซไม่สามารถกำหนดการนำไปใช้งานได้ แต่ตอนนี้สามารถเพิ่มการใช้งานเริ่มต้นสำหรับวิธีการอินเทอร์เฟซได้ นอกจากนี้เรายังสามารถกำหนดวิธีการคงที่และเริ่มต้นได้ซึ่ง สามารถเรียกได้โดยไม่ต้องมีอ็อบเจ็กต์ในอินเทอร์เฟซ ส่วนใหญ่จะใช้อินเทอร์เฟซเพื่อให้ได้รับมรดกหลายรายการและการมีเพศสัมพันธ์แบบหลวม ๆในโค้ด ตอนนี้เรามีความเข้าใจที่ชัดเจนเกี่ยวกับอินเทอร์เฟซแล้ว เรามาดูกันว่าอินเทอร์เฟซการทำงานคืออะไรและทำงานอย่างไร
อินเทอร์เฟซการทำงานคืออะไร?
อินเทอร์เฟซการทำงานเรียกอีกอย่างว่าอินเทอร์เฟซ Single Abstract Method (SAM) ตามชื่อของมัน มันสามารถมีวิธีนามธรรมได้มากสุดหนึ่งวิธี อินเทอร์เฟซการทำงานสามารถมีวิธีการคงที่และค่าเริ่มต้นได้หลายวิธีพร้อมการใช้งานตลอดจนวิธีนามธรรมเพิ่มเติม ในการทำเครื่องหมายอินเทอร์เฟซว่าใช้งานได้จะ ใช้คำอธิบาย ประกอบ @FunctionalInterface จำเป็นต้องหลีกเลี่ยงการประกาศวิธีการเพิ่มเติมอย่างผิดพลาด สิ่งที่ทำให้อินเทอร์เฟซการใช้งานเป็นที่นิยมคือความสามารถในการใช้นิพจน์แลมบ์ดาเพื่อสร้างอินเทอร์เฟซโดยไม่ต้องใช้การใช้งานคลาสที่ไม่ระบุชื่อและยุ่งยาก การใช้ คีย์เวิร์ดabstractในส่วนต่อประสานการทำงานเป็นทางเลือก เนื่องจากวิธีการที่กำหนดไว้ภายในส่วนต่อประสานนั้นเป็นนามธรรมตามค่าเริ่มต้นนิพจน์แลมบ์ดาคืออะไร?
นิพจน์แลมบ์ดาเป็นวิธีการที่ไม่มีชื่อหรือไม่ระบุชื่อซึ่งไม่ได้ดำเนินการด้วยตัวเอง แต่ใช้เพื่อนำวิธีการบางอย่างไปใช้ในอินเทอร์เฟซการทำงาน มันถูกกำหนดไว้ดังนี้:(parameter list) -> lambda body
ตัวดำเนินการลูกศร ( -> ) ที่คุณเห็นในโค้ดเรียกว่าตัวดำเนินการแลมบ์ดา ตัวอย่างเช่น ถ้าเรามีวิธีดังต่อไปนี้:
double getGoldenRatioValue() {
return 1.61803;
}
เมื่อใช้นิพจน์แลมบ์ดา เราสามารถเขียนได้ดังนี้:
() -> 1.61803
อย่างที่คุณเห็น เมธอดในฟังก์ชัน lambda ไม่มีพารามิเตอร์ ดังนั้นด้านซ้ายของคำสั่งจึงว่างเปล่า เนื่องจากทางด้านขวาเป็นตัวกำหนดการกระทำ ในตัวอย่างนี้จะส่งกลับค่าของอัตราส่วนทองคำ: 1.61803 ก่อน Java 8 การใช้อินเทอร์เฟซหรือการสร้างอ็อบเจ็กต์คลาสภายในเป็นสิ่งสำคัญ แต่สำหรับ Java 8 สิ่งที่เราต้องทำตอนนี้คือกำหนดนิพจน์แลมบ์ดาให้กับอินเทอร์เฟซที่ใช้งานได้
ตัวอย่างของอินเทอร์เฟซการทำงาน
ในการสร้างอินเทอร์เฟซการทำงาน คุณสามารถใช้ คำอธิบายประกอบ @FunctionalInterfaceหรือใช้อินเทอร์เฟซการทำงานที่กำหนดไว้ล่วงหน้าของ Javaตัวอย่างที่ 1
- ขั้นแรก เราจะแท็ก@FunctionalInterfaceและสร้างอินเทอร์เฟซที่เรียกว่าMyInterface ที่ถูกเรียกโดยเมธอด abstract getGoldenRationValue()
- จากนั้นเราจะสร้างคลาสสาธารณะหลักเพื่อดำเนินการเมธอด
- หากต้องการใช้นิพจน์ lambda ในอินเทอร์เฟซการทำงาน เราจะประกาศการอ้างอิงถึงMyInterfaceDemoจากนั้นกำหนดนิพจน์ lambda ให้กับการอ้างอิงนั้น
- สุดท้าย เราจะพิมพ์ค่าอัตราส่วนทองคำโดยใช้อินเทอร์เฟซอ้างอิง
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());
}
}
บทสรุป:
มูลค่าอัตราส่วนทองคำ = 1.61803
ตัวอย่างที่ 2
- ในตัวอย่างนี้ เราจะใช้อินเทอร์เฟซฟังก์ชันที่กำหนดไว้ล่วงหน้าToDoubleFunctionซึ่งรับ อาร์กิวเมนต์ Tและส่งกลับค่าdoubleเป็นเอาต์พุต
- ToDoubleFuntionมีเมธอดนามธรรมที่เรียกว่าApplyasDouble( )
- สุดท้าย เราจะพิมพ์ข้อความตามความยาวทั้งหมด รวมถึงการเว้นวรรคด้วย
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."));
}
}
บทสรุป:
54.0
รายการอินเทอร์เฟซการทำงานที่ติดตั้งไว้ล่วงหน้า
ตอนนี้เรารู้วิธีกำหนดอินเทอร์เฟซการทำงานแล้ว มาดูกันว่ามีอินเทอร์เฟซการทำงานที่กำหนดไว้ล่วงหน้า (ในตัว) จำนวนเท่าใด อินเทอร์เฟซการทำงานมี 4 ประเภทหลักที่สามารถนำไปใช้ในสถานการณ์ที่แตกต่างกัน: Consumer , Predicate , FunctionและSupplier ในบรรดาอินเทอร์เฟซทั้งสี่นี้Consumer , FunctionและPredicateมีอินเทอร์เฟซฟังก์ชันเพิ่มเติม นี่คือรายการอินเทอร์เฟซในตัวหรือที่กำหนดไว้ล่วงหน้าทั้งหมดใน Java บันทึก. T, U และ R ที่กล่าวถึงในตารางด้านล่างแสดงถึงประเภทของอาร์กิวเมนต์แรก (T) อาร์กิวเมนต์ที่สอง (U) และผลลัพธ์ (R) ของการดำเนินการตามลำดับมาสรุปกัน
ประเด็นสำคัญบางประการที่ต้องจำจากโพสต์นี้:- อินเทอร์เฟซทำงานเป็นกลไกนามธรรม
- อินเทอร์เฟซการทำงานสามารถมีวิธีการคงที่และค่าเริ่มต้นได้หลายวิธีพร้อมการใช้งานตลอดจนวิธีนามธรรมเพิ่มเติม
- วิธีการที่กำหนดไว้ภายในอินเทอร์เฟซการทำงานจะเป็นแบบนามธรรมตามค่าเริ่มต้น ดังนั้นการใช้ คำสำคัญแบบนามธรรมจึงไม่จำเป็นอีกต่อไป
- นิพจน์แลมบ์ดาเป็นวิธีการที่ไม่ระบุชื่อซึ่งไม่ได้ดำเนินการด้วยตัวเอง แต่ใช้เพื่อนำวิธีการบางอย่างไปใช้ในอินเทอร์เฟซการทำงาน
- ในการสร้างอินเทอร์เฟซการทำงาน คุณสามารถใช้ คำอธิบายประกอบ @FunctionalInterfaceหรือใช้อินเทอร์เฟซการทำงานที่กำหนดไว้ล่วงหน้าของ Java
GO TO FULL VERSION