ส่วนต่อประสานการทำงานที่ใช้ใน Java 8 คืออะไร?

ฉันเจอคำศัพท์ใหม่ใน Java 8: "functional interface" ฉันเท่านั้นที่สามารถหาหนึ่งใช้ประโยชน์จากมันขณะที่ทำงานกับการแสดงออกแลมบ์ดา

Java 8 มีอินเทอร์เฟซการทำงานบางอย่างในตัวและหากเราต้องการกำหนดอินเตอร์เฟสการทำงานใด ๆ เราสามารถใช้@FunctionalInterfaceคำอธิบายประกอบได้ มันจะช่วยให้เราประกาศเพียงวิธีเดียวในอินเทอร์เฟซ

ตัวอย่างเช่น:

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

มีประโยชน์อย่างไรใน Java 8 นอกเหนือจากการทำงานกับการแสดงออกแลมบ์ดา ?

(คำถามที่นี่แตกต่างจากที่ฉันถามมันถามว่าทำไมเราถึงต้องมีอินเตอร์เฟซที่ใช้งานได้ในขณะที่ทำงานกับการแสดงออกแลมบ์ดาคำถามของฉันคือ: ทำไมการใช้งานอื่น ๆ

@FunctionalInterfaceคำอธิบายประกอบมีประโยชน์สำหรับการตรวจสอบเวลารวบรวมรหัสของคุณ คุณไม่สามารถมีมากกว่าหนึ่งวิธีนอกจากstaticนี้defaultและวิธีนามธรรมที่แทนที่วิธีการในอินเทอร์เฟซObjectของคุณ@FunctionalInterfaceหรืออื่น ๆ ที่ใช้เป็นส่วนต่อประสานการทำงาน

แต่คุณสามารถใช้ lambdas โดยไม่มีคำอธิบายประกอบนี้ได้เช่นเดียวกับคุณสามารถแทนที่วิธีการโดยไม่ต้องใส่@Overrideคำอธิบายประกอบ

จากเอกสาร

ส่วนต่อประสานการทำงานมีวิธีนามธรรมอย่างหนึ่งอย่างแน่นอน เนื่องจากวิธีการเริ่มต้นมีการใช้งานพวกเขาจึงไม่เป็นนามธรรม หากอินเตอร์เฟสประกาศวิธีนามธรรมแทนที่หนึ่งในวิธีสาธารณะของ java.lang.Object ที่ไม่นับรวมกับวิธีนามธรรมของอินเทอร์เฟซนับตั้งแต่การดำเนินการของอินเทอร์เฟซใด ๆ จะมีการใช้งานจาก java.lang.Object หรืออื่น ๆ

สิ่งนี้สามารถใช้ในการแสดงออกแลมบ์ดา:

public interface Foo {
  public void doSomething();
}

สิ่งนี้ไม่สามารถใช้ในการแสดงออกแลมบ์ดา:

public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

แต่สิ่งนี้จะทำให้เกิดข้อผิดพลาดในการรวบรวม :

@FunctionalInterface
public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

คำอธิบายประกอบ '@FunctionalInterface' ไม่ถูกต้อง Foo ไม่ใช่อินเทอร์เฟซที่ใช้งานได้

เอกสารทำให้ย่อมเป็นความแตกต่างระหว่างวัตถุประสงค์

ชนิดคำอธิบายประกอบแบบให้ข้อมูลที่ใช้เพื่อระบุว่าการประกาศชนิดอินเตอร์เฟสมีวัตถุประสงค์เพื่อเป็นอินเตอร์เฟสการทำงานตามที่กำหนดโดย Java Language Specification

และกรณีการใช้งาน

โปรดทราบว่าอินสแตนซ์ของอินเทอร์เฟซที่ใช้งานได้สามารถสร้างได้ด้วยการแสดงออกแลมบ์ดาการอ้างอิงเมธอดหรือการอ้างอิงคอนสตรัคเตอร์

การใช้ถ้อยคำไม่ได้ จำกัด กรณีการใช้งานอื่นโดยทั่วไป เนื่องจากจุดประสงค์หลักคือเพื่อระบุอินเทอร์เฟซที่ใช้งานได้คำถามที่แท้จริงของคุณจึงลดลงถึง“ มีกรณีการใช้งานอื่น ๆ สำหรับส่วนต่อประสานการทำงานอื่น ๆ นอกเหนือจากการแสดงออกแลมบ์ดา

เนื่องจากส่วนต่อประสานการทำงานเป็นโครงสร้างภาษา Java ที่กำหนดโดย Java Language Specification จึงมีเพียงข้อมูลจำเพาะเท่านั้นที่สามารถตอบคำถามได้:

JLS §9.8 ฟังก์ชั่นการเชื่อมต่อ :

...

นอกเหนือจากกระบวนการปกติในการสร้างอินสแตนซ์ของอินเทอร์เฟซโดยการประกาศและสร้างอินสแตนซ์ของคลาส (§15.9) อินสแตนซ์ของอินเทอร์เฟซที่ใช้งานได้สามารถสร้างได้ด้วยนิพจน์อ้างอิงวิธีการ

ดังนั้น Java Language Specification ไม่ได้พูดเป็นอย่างอื่นกรณีใช้งานเดียวที่กล่าวถึงในส่วนนั้นคือการสร้างอินสแตนซ์ของอินเทอร์เฟซที่มีนิพจน์อ้างอิงเมธอดและนิพจน์แลมบ์ดา (ซึ่งรวมถึงการอ้างอิงคอนสตรัคตามที่ระบุไว้ในรูปแบบหนึ่งของการแสดงออกวิธีการอ้างอิงในสเปค)

ดังนั้นในหนึ่งประโยคไม่ไม่มีกรณีการใช้งานอื่นสำหรับ Java 8

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

ไม่ใช่เลย. นิพจน์แลมบ์ดาเป็นเพียงจุดเดียวของคำอธิบายประกอบนั้น

นิพจน์แลมบ์ดาสามารถกำหนดให้กับประเภทอินเตอร์เฟสที่ใช้งานได้ แต่สามารถอ้างอิงวิธีการและคลาสที่ไม่ระบุชื่อได้

สิ่งหนึ่งที่ดีเกี่ยวกับการเชื่อมต่อการทำงานที่เฉพาะเจาะจงในการjava.util.functionที่พวกเขาสามารถจะประกอบด้วยการสร้างฟังก์ชั่นใหม่ (ชอบFunction.andThenและFunction.compose, Predicate.andฯลฯ ) เนื่องจากวิธีการเริ่มต้นที่มีประโยชน์ที่พวกเขามี

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

package com.akhi;
    @FunctionalInterface
    public interface FucnctionalDemo {

      void letsDoSomething();
      //void letsGo();      //invalid because another abstract method does not allow
      public String toString();    // valid because toString from Object 
      public boolean equals(Object o); //valid

      public static int sum(int a,int b)   // valid because method static
        {   
            return a+b;
        }
        public default int sub(int a,int b)   //valid because method default
        {
            return a-b;
        }
    }

ฟังก์ชั่นการเชื่อมต่อ:

• แนะนำใน Java 8
• อินเทอร์เฟซที่ประกอบด้วยวิธีการ "นามธรรมเดียว"

ตัวอย่างที่ 1:

   interface CalcArea {   // --functional interface
        double calcArea(double rad);
    }           

ตัวอย่างที่ 2:

interface CalcGeometry { // --functional interface
    double calcArea(double rad);
    default double calcPeri(double rad) {
        return 0.0;
    }
}       

ตัวอย่างที่ 3:

interface CalcGeometry {  // -- not functional interface
    double calcArea(double rad);
    double calcPeri(double rad);
}   

คำอธิบายประกอบ Java8 - @FunctionalInterface

• ตรวจสอบหมายเหตุประกอบว่าอินเตอร์เฟสมีวิธีนามธรรมเพียงวิธีเดียว ถ้าไม่ยกข้อผิดพลาด
• แม้ว่า @FunctionalInterface หายไป แต่ก็ยังคงเป็นฟังก์ชันการใช้งาน (หากมีวิธีการแบบนามธรรมเดียว) คำอธิบายประกอบช่วยหลีกเลี่ยงข้อผิดพลาด
• ส่วนต่อประสานการทำงานอาจมีวิธีคงที่และค่าเริ่มต้นเพิ่มเติม
• เช่น Iterable <>, Comparable <>, Comparator <>

การประยุกต์ใช้ฟังก์ชั่นอินเตอร์เฟซ:

• วิธีการอ้างอิง
• แลมบ์ดานิพจน์
• การอ้างอิงคอนสตรัค

หากต้องการเรียนรู้ส่วนต่อประสานการทำงานให้เรียนรู้วิธีการเริ่มต้นเป็นครั้งแรกในส่วนต่อประสานและหลังจากเรียนรู้ส่วนต่อประสานการทำงานแล้วคุณจะสามารถเข้าใจวิธีการอ้างอิงและการแสดงออกแลมบ์ดาได้ง่าย

คุณสามารถใช้แลมบ์ดาใน Java 8

public static void main(String[] args) {
    tentimes(inputPrm - > System.out.println(inputPrm));
    //tentimes(System.out::println);  // You can also replace lambda with static method reference
}

public static void tentimes(Consumer myFunction) {
    for (int i = 0; i < 10; i++)
        myFunction.accept("hello");
}

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับJava LambdasและFunctionalInterfaces

@FunctionalInterface เป็นคำอธิบายประกอบใหม่ออกวางจำหน่ายกับ Java 8 และให้ประเภทเป้าหมายสำหรับการแสดงออกแลมบ์ดาและมันใช้ในการตรวจสอบเวลารวบรวมของรหัสของคุณ

เมื่อคุณต้องการใช้:

1- อินเตอร์เฟซของคุณต้องไม่มีวิธีนามธรรมมากกว่าหนึ่งวิธีมิฉะนั้นจะมีข้อผิดพลาดในการรวบรวม

1- อินเทอร์เฟซของคุณควรจะบริสุทธิ์ซึ่งหมายความว่าอินเทอร์เฟซที่ใช้งานได้ตั้งใจที่จะใช้งานโดยคลาสไร้สัญชาติส่วนเกินของบริสุทธิ์คือComparatorอินเทอร์เฟซเนื่องจากไม่ขึ้นอยู่กับสถานะของผู้ใช้งานในกรณีนี้ไม่มีข้อผิดพลาด จะไม่สามารถใช้แลมบ์ดากับอินเทอร์เฟซชนิดนี้ได้

java.util.functionแพคเกจประกอบด้วยต่างๆอเนกประสงค์อินเตอร์เฟซที่ทำงานเช่นPredicate, Consumer, และFunctionSupplier

นอกจากนี้โปรดทราบว่าคุณสามารถใช้ lambdas โดยไม่มีคำอธิบายประกอบนี้

นอกเหนือจากคำตอบอื่น ๆ ฉันคิดว่าเหตุผลหลักที่ "ทำไมการใช้ Interface Interface นอกเหนือจากโดยตรงกับการแสดงออกแลมบ์ดา" สามารถเกี่ยวข้องกับธรรมชาติของภาษา Java ซึ่งเป็น Object Oriented

คุณลักษณะหลักของการแสดงออกของแลมบ์ดาคือ: 1. สามารถส่งผ่านได้ประมาณ 2 ครั้งและสามารถดำเนินการในอนาคตในเวลาที่กำหนด (หลายครั้ง) ตอนนี้เพื่อรองรับฟีเจอร์นี้ในภาษาอื่น ๆ บางภาษาจัดการกับเรื่องนี้ได้ง่ายๆ

ยกตัวอย่างเช่นในจาวาสคริปต์สามารถใช้ฟังก์ชั่น (ฟังก์ชั่นที่ไม่ระบุชื่อหรือฟังก์ชั่นตัวอักษร) เป็นวัตถุ ดังนั้นคุณสามารถสร้างพวกเขาได้อย่างง่ายดายและพวกเขาสามารถกำหนดให้กับตัวแปรและอื่น ๆ ตัวอย่างเช่น:

var myFunction = function (...) {
    ...;
}
alert(myFunction(...));

หรือผ่าน ES6 คุณสามารถใช้ฟังก์ชั่นลูกศร

const myFunction = ... => ...

ถึงตอนนี้ผู้ออกแบบภาษาจาวายังไม่ได้รับการยอมรับในการจัดการคุณสมบัติที่กล่าวถึงผ่านวิธีการเหล่านี้ (เทคนิคการเขียนโปรแกรมการทำงาน) พวกเขาเชื่อว่าภาษา Java เป็น Object Oriented ดังนั้นพวกเขาควรแก้ปัญหานี้ด้วยเทคนิค Object Oriented พวกเขาไม่ต้องการที่จะคิดถึงความเรียบง่ายและความสอดคล้องของภาษาจาวา

ดังนั้นพวกเขาใช้อินเทอร์เฟซเมื่อวัตถุของอินเทอร์เฟซด้วยวิธีเดียว (ฉันหมายถึงอินเทอร์เฟซการทำงาน) จำเป็นต้องคุณสามารถแทนด้วยแลมบ์ดานิพจน์ เช่น:

ActionListener listener = event -> ...;