Question

我想出了一个泛型函数foo，该函数链接了两个泛型函数，同时捕获了泛型异常并返回了泛型。但是我不能调用它。这里的类型和参数可能有点令人困惑，但是在这里使用更多冗长的名称也不会造成混乱。

函数bar应该提供所有通用类型来推断它们，但是它显示了编译错误，我也不能显式地添加它们（execute<E, Class<D>, D, IOException>(...)的结果是'不适用于自变量'）。

我已经尝试绕了几个小时，并使用fooBar编译没有问题。因此，我认为类型兼容性没有问题，而是我如何在foo中调用bar或如何推断它们。

public class A {
    // similiar to BiFunction but throws Exception
    static interface Foo<P1, P2, R> { R apply(P1 p1, P2 p2) throws Exception; }
    static class Bar extends RuntimeException { /*...*/ }

    public static <R1, D1, R2, E1 extends Exception> R2 foo(Foo<B, C, R1> arg1, C arg2, BiFunction<R1, Class<D1>, R2> arg3, Class<E1> arg4, Class<D1> arg5) {
        try {
            B b1 = new B();
            R1 r1 = arg1.apply(b1, arg2);
            return arg3.apply(r1, arg5);
        } catch (Exception e1) {
            if (arg4.isInstance(e1)) {
                return null;
            }
            throw new Bar();
        }
    }

    public static D bar() {
        Foo<B, C, E> foo1 = (b1, c1) -> b1.foo(c1); // where B.foo(C) returns E
        BiFunction<E, Class<D>, D> bar1 = (e1, cClass) -> e1.bar(cClass); // where E.bar(Class<D>) returns D
        return foo(foo1, new C(), bar1, new IOException(), new D()); // compile error: cannot infer generic type arguments
    }

    public static D fooBar() {
        Foo<B, C, E> foo1 = (b1, c1) -> b1.foo(c1); // where B.foo(C) returns E
        BiFunction<E, Class<D>, D> bar1 = (e1, cClass) -> e1.bar(cClass); // where E.bar(Class<D>) returns D
        try {
            B b1 = new B();
            E e1 = foo1.apply(b1, new C());
            return bar1.apply(e1, D.class);
        } catch (Exception e1) {
            if (IOException.class.isInstance(e1)) {
                return null;
            }
            throw new Bar();
        }
    }
}

这花费了无限长的时间来粘贴和格式化，如果打错了任何内容，我感到抱歉。 如何调用foo，以便推断出通用类型参数？

Answer 1

foo的第四和第五个参数期望Class，但是您给它一个IOException和一个D。

您可能打算给它IOException.class和D.class：

return foo(foo1, new C(), bar1, IOException.class, D.class);

从嵌套泛型推断出泛型类型参数

1 个答案: