Java中Lambda函数重复代码的抽象方法探讨

当然可以对这些重复代码进行抽象，核心思路是把通用预处理逻辑抽离出来，将差异化的后续逻辑作为回调传入。以下是两种实用的实现方式：

方式一：提取通用预处理方法+函数式回调 #

这种方式利用Java的函数式接口，让差异化逻辑以Lambda形式传入，保持代码简洁灵活。

步骤1：定义处理后续逻辑的函数式接口 #

@FunctionalInterface
public interface PostOrganizeHandler {
    // 接收预处理后的三个变量，执行专属逻辑
    void handle(String path, String processedValue, Object organizedValue);
}

步骤2：抽离通用预处理逻辑 #

把两个Lambda中重复的判断和变量处理逻辑封装成单独方法：

// 假设PREFIX、callOrganizer是已定义的常量/方法
private static void processOrganizeCommon(List<String> orgPath, Schema schema, Value value, PostOrganizeHandler handler) {
    if (schema.isOrganizable()) {
        // 原重复代码逻辑
        String path = orgPath.get(0); // 注意：原代码中orgPath.get()需确认索引，这里假设取第一个元素
        String processedValue = PREFIX + value.get();
        Object organizedValue = callOrganizer(path, processedValue);
        
        // 调用后续专属逻辑
        handler.handle(path, processedValue, organizedValue);
    }
}

步骤3：重构原有Lambda #

现在可以用简洁的Lambda替换原来的重复代码：

public static void organizeBooks() {
    OrganizerFunc organizeBooksFunc = (orgPath, schema, value) -> {
        processOrganizeCommon(orgPath, schema, value, (path, val, organizedVal) -> {
            // 这里保留书籍专属的后续代码
            // 示例：
            System.out.println("整理书籍路径：" + path);
            // ...其他书籍逻辑
        });
    };
}

public static void organizeToys() {
    OrganizerFunc organizeToysFunc = (orgPath, schema, value) -> {
        processOrganizeCommon(orgPath, schema, value, (path, val, organizedVal) -> {
            // 这里保留玩具专属的后续代码
            // 示例：
            System.out.println("整理玩具路径：" + path);
            // ...其他玩具逻辑
        });
    };
}

方式二：使用抽象类实现模板方法模式 #

如果后续需要扩展更多通用逻辑，抽象类的方式会更易维护，符合模板方法的设计思想。

步骤1：定义抽象类实现通用逻辑 #

public abstract class AbstractOrganizer implements OrganizerFunc {
    @Override
    public void organize(List<String> orgPath, Schema schema, Value value) {
        if (schema.isOrganizable()) {
            // 通用预处理逻辑
            String path = orgPath.get(0);
            String processedValue = PREFIX + value.get();
            Object organizedValue = callOrganizer(path, processedValue);
            
            // 调用子类实现的专属逻辑
            doPostOrganize(path, processedValue, organizedValue);
        }
    }

    // 子类需实现的专属后续逻辑方法
    protected abstract void doPostOrganize(String path, String processedValue, Object organizedValue);
}

步骤2：实现书籍和玩具的专属类 #

public static void organizeBooks() {
    OrganizerFunc organizeBooksFunc = new AbstractOrganizer() {
        @Override
        protected void doPostOrganize(String path, String processedValue, Object organizedValue) {
            // 书籍专属后续逻辑
        }
    };
}

public static void organizeToys() {
    OrganizerFunc organizeToysFunc = new AbstractOrganizer() {
        @Override
        protected void doPostOrganize(String path, String processedValue, Object organizedValue) {
            // 玩具专属后续逻辑
        }
    };
}

两种方式对比 #

• 函数式回调：代码更简洁，适合快速实现小范围逻辑复用，Lambda写法更符合现代Java风格。
• 抽象类模板：适合需要扩展更多通用逻辑的场景，后续新增同类Organizer时只需实现抽象方法，扩展性更强。

内容的提问来源于stack exchange，提问作者Punter Vicky