คอฟฟี่เบรค #182. อินเทอร์เฟซการทำงานใน Java

ที่มา: 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());
}
}

บทสรุป:

ตัวอย่างที่ 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."));
}
}

บทสรุป:

รายการอินเทอร์เฟซการทำงานที่ติดตั้งไว้ล่วงหน้า

ตอนนี้เรารู้วิธีกำหนดอินเทอร์เฟซการทำงานแล้ว มาดูกันว่ามีอินเทอร์เฟซการทำงานที่กำหนดไว้ล่วงหน้า (ในตัว) จำนวนเท่าใด อินเทอร์เฟซการทำงานมี 4 ประเภทหลักที่สามารถนำไปใช้ในสถานการณ์ที่แตกต่างกัน: Consumer , Predicate , FunctionและSupplier ในบรรดาอินเทอร์เฟซทั้งสี่นี้Consumer , FunctionและPredicateมีอินเทอร์เฟซฟังก์ชันเพิ่มเติม นี่คือรายการอินเทอร์เฟซในตัวหรือที่กำหนดไว้ล่วงหน้าทั้งหมดใน Java บันทึก. T, U และ R ที่กล่าวถึงในตารางด้านล่างแสดงถึงประเภทของอาร์กิวเมนต์แรก (T) อาร์กิวเมนต์ที่สอง (U) และผลลัพธ์ (R) ของการดำเนินการตามลำดับ

มาสรุปกัน

ประเด็นสำคัญบางประการที่ต้องจำจากโพสต์นี้:

• อินเทอร์เฟซทำงานเป็นกลไกนามธรรม
• อินเทอร์เฟซการทำงานสามารถมีวิธีการคงที่และค่าเริ่มต้นได้หลายวิธีพร้อมการใช้งานตลอดจนวิธีนามธรรมเพิ่มเติม
• วิธีการที่กำหนดไว้ภายในอินเทอร์เฟซการทำงานจะเป็นแบบนามธรรมตามค่าเริ่มต้น ดังนั้นการใช้ คำสำคัญแบบนามธรรมจึงไม่จำเป็นอีกต่อไป
• นิพจน์แลมบ์ดาเป็นวิธีการที่ไม่ระบุชื่อซึ่งไม่ได้ดำเนินการด้วยตัวเอง แต่ใช้เพื่อนำวิธีการบางอย่างไปใช้ในอินเทอร์เฟซการทำงาน
• ในการสร้างอินเทอร์เฟซการทำงาน คุณสามารถใช้ คำอธิบายประกอบ @FunctionalInterfaceหรือใช้อินเทอร์เฟซการทำงานที่กำหนดไว้ล่วงหน้าของ Java