如何让Function组合结果兼容Operation类型？Java技术问询

你遇到的这个问题其实很典型——JDK的Function.andThen()和compose()方法返回的是JDK内部生成的匿名Lambda实现（就是你报错里的Function$$Lambda$xxx），它根本不是你自定义的Operation子类，所以强制类型转换必然抛出ClassCastException。

要实现组合后的对象依然是Operation类型，我们可以通过自定义组合逻辑来实现，下面给你两种可行的方案：

方案一：在Operation抽象类中添加自定义组合方法 #

直接在抽象类里实现返回Operation的组合方法，避免使用JDK默认的andThen/compose：

import java.util.function.Function;

public abstract class Operation implements Function<Integer, Integer> {

    // 自定义andThen，返回Operation类型
    public Operation andThenOp(Operation after) {
        return new Operation() {
            @Override
            public Integer apply(Integer integer) {
                return after.apply(Operation.this.apply(integer));
            }
        };
    }

    // 自定义compose，返回Operation类型
    public Operation composeOp(Operation before) {
        return new Operation() {
            @Override
            public Integer apply(Integer integer) {
                return Operation.this.apply(before.apply(integer));
            }
        };
    }
}

public class OpA extends Operation {
    @Override
    public Integer apply(Integer integer) {
        // 示例逻辑：输入值加1
        return integer + 1;
    }
}

public class Main {
    public static void main(String[] args) {
        OpA a = new OpA();
        OpA b = new OpA();
        
        // 组合后的对象直接是Operation类型，无需强制转换
        Operation composed = a.andThenOp(b);
        System.out.println(composed.apply(1)); // 输出3，符合预期
    }
}

这种方式简单直接，不需要额外的类，通过匿名内部类包装组合逻辑，返回的就是Operation实例。

方案二：创建专门的组合类CompositeOperation #

如果需要更清晰的结构，可以创建一个继承自Operation的组合类，专门处理多个Operation的串联：

import java.util.function.Function;

public abstract class Operation implements Function<Integer, Integer> {}

public class OpA extends Operation {
    @Override
    public Integer apply(Integer integer) {
        // 示例逻辑：输入值加1
        return integer + 1;
    }
}

// 专门的组合类，封装多Operation的串联逻辑
public class CompositeOperation extends Operation {
    private final Function<Integer, Integer> combinedFunction;

    private CompositeOperation(Function<Integer, Integer> combined) {
        this.combinedFunction = combined;
    }

    // 静态工厂方法：创建andThen类型的组合
    public static CompositeOperation andThen(Operation first, Operation second) {
        return new CompositeOperation(first.andThen(second));
    }

    // 静态工厂方法：创建compose类型的组合
    public static CompositeOperation compose(Operation first, Operation second) {
        return new CompositeOperation(first.compose(second));
    }

    @Override
    public Integer apply(Integer integer) {
        return combinedFunction.apply(integer);
    }
}

public class Main {
    public static void main(String[] args) {
        OpA a = new OpA();
        OpA b = new OpA();
        
        Operation composed = CompositeOperation.andThen(a, b);
        System.out.println(composed.apply(1)); // 输出3
    }
}

这种方式把组合逻辑封装在专门的类里，扩展性更好，比如后续可以轻松支持多个Operation的链式组合。

补充：覆盖Function的默认方法（可选） #

如果你想直接用andThen和compose方法名，可以覆盖Function的默认方法，让它们返回Operation类型：

import java.util.function.Function;

public abstract class Operation implements Function<Integer, Integer> {

    @Override
    public Operation andThen(Function<? super Integer, ? extends Integer> after) {
        // 包装组合逻辑，返回Operation实例
        return integer -> after.apply(this.apply(integer));
    }

    @Override
    public Operation compose(Function<? super Integer, ? extends Integer> before) {
        return integer -> this.apply(before.apply(integer));
    }
}

这样调用a.andThen(b)时，返回的直接就是Operation类型，无需任何强制转换，而且即使传入的after不是Operation实例，也会被自动包装成Operation返回。

总结一下，核心思路就是不要依赖JDK默认方法返回的Lambda实例，而是自己生成Operation类型的实例来包装组合逻辑，这样就能保证组合后的对象始终是Operation兼容的类型。

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