Java 如何同时实现函数和双函数？

我创建了一个类

GenericFunction

，它实现了

Function

和

BiFunction

。但它不能被编译

public class GenericFunction<T, U, R> implements
        Function<T, R>, BiFunction<T, U, R> {

    @Override
    public R apply(T t, U u) {
        return null;
    }

    @Override
    public R apply(T t) {
        return null;
    }

}

公共类GenericFunction实现
双功能{
@凌驾
公共R应用（T，U）{
返回null；
}
@凌驾
公共R应用（T）{
返回null；
}
}

错误消息是：

src\obscure\test\GenericFunction.java:6: error:
types BiFunction<T,U,R> and Function<T,R> are incompatible;
both define andThen(java.util.function.Function<? super R,? extends V>),
but with unrelated return types
public class GenericFunction<T, U, R> implements
       ^
where T,U,R are type-variables:
  T extends Object declared in class GenericFunction
  U extends Object declared in class GenericFunction
  R extends Object declared in class GenericFunction

1 error

src\ambize\test\GenericFunction.java:6:错误：
双函数和函数类型不兼容；
我不知道你为什么想要这样的东西，但这似乎是一个有趣的挑战

主要问题是，函数和双函数都实现了默认的
和
函数，它们都具有完全相同的签名，因此您的类不知道要调用哪个。您只需提供自己的实现，它就不再含糊不清了。不过实现起来很棘手

java文档称该方法：

返回一个组合函数，该函数首先将此函数应用于其输入，然后将after函数应用于结果

…这意味着返回一个新的GenericFunction，其中两个apply方法现在都是组合

我给你这个怪物：

public class GenericFunction<T, U, R> implements Function<T, R>, BiFunction<T, U, R> {

    @Override
    public R apply(T t, U u) {
        return null;
    }

    @Override
    public R apply(T t) {
        return null;
    }

    @Override
    public <V> GenericFunction<T, U, V>  andThen(Function<? super R, ? extends V> after) {
        return new GenericFunctionAndThen<>(after);
    }

    private class GenericFunctionAndThen<V> extends GenericFunction<T, U, V> {
        private final Function<? super R, ? extends V> after;

        public GenericFunctionAndThen(Function<? super R, ? extends V> after) {
            this.after = after;
        }

        @Override
        public V apply(T t) {
            return after.apply(GenericFunction.this.apply(t));
        }

        @Override
        public V apply(T t, U u) {
            return after.apply(GenericFunction.this.apply(t, u));
        }
    }
}

公共类GenericFunction实现函数，双函数{
@凌驾
公共R应用（T，U）{
返回null；
}
@凌驾
公共R应用（T）{
返回null；
}
@凌驾
公共泛型函数，然后（函数从扩展而来，我不喜欢的一点是，
GenericFunction，然后
扩展
GenericFunction
，而不重用它的超类的任何行为——在我看来，这是一个坏消息

如果您将
GenericFunction
实现为一个接口，那么事情会变得更干净：

public interface GenericFunction<T, U, R> extends Function<T, R>, BiFunction<T, U, R> {
    @Override
    default <V> GenericFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        return new GenericFunction<T, U, V>() {
            @Override
            public V apply(final T t, final U u) {
                return after.apply(GenericFunction.this.apply(t, u));
            }

            @Override
            public V apply(final T t) {
                return after.apply(GenericFunction.this.apply(t));
            }
        };
    }
}

公共接口通用函数扩展函数，双函数{
@凌驾
默认的GenericFunction，然后（FunctionI将其与Lambda表达式一起使用：）更重要的是：你为什么要这样做？@RobbyCornelissen我正在实现一个Lisp解释器。这个类是Lisp中的lambda函数。错误信息非常清楚：
类型BiFunction和function是不兼容的
…当然！这是我很久以来写的最疯狂的Java，可能是有史以来写的。它仍然很干净，但也…疯狂。你真是太棒了编写Lisp解释器？你听说过Clojure，对吧？：）是的，我知道。但我想写一些类似于
（（123map的流）（lambda（x）（*x）））toArray的东西
。