功能性接口是指在Java中只有一個抽象方法的接口，它為使用lambda表達式和方法引用奠定了基礎。其核心意義在於允許將功能作為方法參數(shù)或把代碼當作數(shù)據(jù)處理，從而使代碼更簡潔、可讀性更高、靈活性更強。判斷一個接口是否為功能性接口的關鍵不在於總方法數(shù)，而在於其擁有的抽象方法數(shù)量：? 僅有一個抽象方法→ 功能性接口；? 兩個或以上抽象方法→ 非功能性接口。即使接口包含默認方法或靜態(tài)方法，這些都不計入抽象方法總數(shù)。 1. 可通過@FunctionalInterface註解明確標識，但非必需。 2. Java內置了多個常用的功能性接口如Function、Predicate、Consumer、Supplier、BiFunction等，廣泛用於流和集合操作。 3. 當內置接口無法滿足需求時，可以創(chuàng)建自定義功能性接口，例如定義帶有兩個參數(shù)並返回布爾值的Validator接口。 4. 自定義適用場景包括：命名更清晰以反映意圖、內置類型過於泛化、設計可重用API等情況。需注意始終確保只含一個抽象方法，否則會破壞功能性接口定義。默認方法不會影響其功能性，IDE和編譯器工具能幫助識別錯誤，尤其是在使用@FunctionalInterface註解時。功能性接口雖表面簡單，卻極大增強了Java的表現(xiàn)力。

A functional interface is an interface in Java that has exactly one abstract method. It's the foundation for using lambda expressions and method references in Java 8 and later versions.

Why Does It Matter?

Because it allows you to treat functionality as a method argument or code as data — which makes your code more concise, readable, and flexible. You've probably used them already if you've worked with streams or the Runnable interface.

What Makes an Interface "Functional"?

It's not about how many methods it has — it's about how many abstract methods it has.

• ? One abstract method → Functional interface
• ? Two or more abstract methods → Not a functional interface

Even if the interface has default or static methods, those don't count toward the abstract method total.

 @FunctionalInterface
interface MyFunc {
    void doSomething(); // Only one abstract method

    default void helperMethod() {
        // This is fine
    }
}

You can annotate it with @FunctionalInterface , but it's optional. Java will still recognize it either way.

Common Examples You'll See

Java comes with several built-in functional interfaces in the java.util.function package. These are widely used in streams and collections:

• Function<T,R> – Takes one input, returns a result (eg, mapping values)
• Predicate<T> – Returns a boolean (eg, filtering)
• Consumer<T> – Performs an action with the input (eg, printing or modifying)
• Supplier<T> – Provides an instance of T (no input, just output)
• BiFunction<T,U,R> – Like Function, but takes two inputs

These make it easy to write clean, expressive code without defining your own interfaces every time.

When Should You Create Your Own?

If none of the built-in ones fit your use case, go ahead and define your own.

For example, if you need a function that takes two arguments and returns a boolean, and you're not happy with BiPredicate , you could define:

 @FunctionalInterface
interface Validator<T, U> {
    boolean isValid(T item1, U item2);
}

Use custom functional interfaces when:

• You want clearer naming that reflects intent
• Built-in types get too generic for your logic
• You're designing a reusable API

Just remember: only one abstract method.

A Few Gotchas to Watch For

• Adding more than one abstract method accidentally breaks the contract.
• Default methods are safe — they don't interfere with being functional.
• If you're implementing a functional interface, be sure you're overriding the correct method.
• Tools like IDEs and compilers help catch mistakes, especially with @FunctionalInterface .

So while functional interfaces look simple on the surface, they open the door to a lot of expressive power in Java.

基本上就這些。

以上是什麼是功能接口？的詳細內容。更多資訊請關注PHP中文網(wǎng)其他相關文章！