Using Java 8 Functional Interfaces to Replace Repetitive if‑else Logic

In Java development, if...else... statements are frequently used for exception throwing and branching, which can make code look cluttered. This article demonstrates how Java 8's functional interfaces can be employed to eliminate such patterns and make code more expressive.

The @FunctionalInterface annotation marks an interface that contains a single abstract method. Java 8 provides several built‑in functional interfaces: Supplier (no arguments, returns a value), Consumer (accepts a value, returns nothing), Runnable (no arguments, no return), and the generic Function (accepts a value and returns a result).

Example of a traditional if block:

if (condition) {
    throw new RuntimeException("出现异常了");
} else {
    doSomething();
}

Using a functional interface, the same logic can be expressed more concisely:

@FunctionalInterface
public interface ThrowExceptionFunction {
    void throwMessage(String message);
}

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

For branch handling, a BranchHandle interface is defined with two Runnable parameters representing the actions for true and false cases:

@FunctionalInterface
public interface BranchHandle {
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}

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

To handle optional values, the PresentOrElseHandler interface accepts a Consumer for non‑null values and a Runnable for the null case:

public interface PresentOrElseHandler
{
    void presentOrElseHandle(Consumer
action, Runnable emptyAction);
}

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

These functional patterns greatly simplify exception handling, conditional branching, and null‑checking logic, leading to cleaner and more maintainable backend code.

Function interfaces are a core feature of Java 8; mastering them can significantly reduce boilerplate and improve overall code quality.