Using Java 8 Functional Interfaces to Replace if…else Branches and Exception Handling

In Java development, if...else statements are frequently used for exception throwing and branch handling, which can make the code look cluttered and hard to read.

Java 8 introduces functional interfaces; by annotating an interface with @FunctionalInterface you guarantee it contains only one abstract method, enabling lambda expressions. Common functional interfaces include Supplier (no arguments, returns a value), Consumer (accepts a value, returns nothing), Runnable (no arguments, no return), and Function (accepts a value and returns a result).

For example, a custom exception‑handling functional interface can be defined as follows:

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

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

This lambda throws a RuntimeException only when the supplied condition is true, removing the need for explicit if blocks throughout the code.

A branch‑handling interface can be created to execute different Runnable actions based on a boolean value:

@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();
        }
    };
}

Similarly, to process optional values, a PresentOrElseHandler interface combines a Consumer for non‑null values and a Runnable for null/empty cases:

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

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

By using these functional interfaces, repetitive if...else logic is encapsulated in concise lambda expressions, improving readability and maintainability of backend Java code.

Overall, leveraging Java 8’s functional programming features allows developers to write cleaner, more expressive code while handling exceptions, branching, and optional values in a declarative style.