Using Java 8 Functional Interfaces to Replace if…else Statements

In Java development, the ubiquitous if...else... pattern for exception throwing and branch handling often clutters code, reducing readability. The article proposes using Java 8's functional interfaces to replace these patterns.

Function Interface

Mark an interface with @FunctionalInterface to indicate it contains a single abstract method. Common functional interfaces include Supplier (no arguments, returns a value), Consumer (accepts an argument, returns void), Runnable (no arguments, no return), and Function (accepts an argument and returns a value).

Function can be seen as a transformation function.

Example 1: ThrowExceptionFunction

/**
 * 抛异常接口
 */
@FunctionalInterface
public interface ThrowExceptionFunction {
    /**
     * 抛出异常信息
     * @param message 异常信息
     */
    void throwMessage(String message);
}

Utility method that returns a ThrowExceptionFunction which throws an exception when the supplied boolean is true :

public static ThrowExceptionFunction isTure(boolean b) {
    return (errorMessage) -> {
        if (b) {
            throw new RuntimeException(errorMessage);
        }
    };
}

Usage: call throwMessage("error") on the returned function; if the parameter is false the method executes normally.

Example 2: BranchHandle

/**
 * 分支处理接口
 */
@FunctionalInterface
public interface BranchHandle {
    /**
     * 分支操作
     * @param trueHandle  为true时要进行的操作
     * @param falseHandle 为false时要进行的操作
     */
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}

Utility method that returns a BranchHandle to execute one of two Runnable s based on a boolean:

public static BranchHandle isTureOrFalse(boolean b) {
    return (trueHandle, falseHandle) -> {
        if (b) {
            trueHandle.run();
        } else {
            falseHandle.run();
        }
    };
}

When b is true the trueHandle runs; otherwise the falseHandle runs.

Example 3: PresentOrElseHandler

/**
 * 空值与非空值分支处理
 */
public interface PresentOrElseHandler
{
    /**
     * 值不为空时执行消费操作，值为空时执行其他的操作
     * @param action      值不为空时的 Consumer
     * @param emptyAction 值为空时的 Runnable
     */
    void presentOrElseHandle(Consumer
action, Runnable emptyAction);
}

Utility method that returns a PresentOrElseHandler for a String :

public static PresentOrElseHandler
isBlankOrNoBlank(String str) {
    return (consumer, runnable) -> {
        if (str == null || str.length() == 0) {
            runnable.run();
        } else {
            consumer.accept(str);
        }
    };
}

Call presentOrElseHandle with a Consumer to process a non‑empty value and a Runnable to handle the empty case.

By defining these functional interfaces and corresponding factory methods, developers can replace verbose if…else blocks with concise lambda expressions, improving code readability and maintainability.

Conclusion

Java 8 functional interfaces are powerful tools; using them wisely can greatly simplify code structures such as exception handling, branch processing, and null‑checking.