2

这是我想做的事情：

我有一个接口服务如下：

public interface Service<A extends Object, R extends Object> {
    R run(A a);
}

现在，我想链接两个这样的服务，同时保持它的通用性：

public class Link<A, R> implements Service<A, R> {

    private Service<A, X> s1; // fail
    private Service<X, R> s2; // fail

    public <X> Link(Service<A, X> s1, Service<X, R> s2) {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public R run(A a) {
        return s2.run(s1.run(a));
    }
}

我要解决的问题是将泛型类型 X 分配给类 Link，但我希望通过其构造函数而不是通过类声明来推断。

它是如何实现的？

编辑：

我解决此问题的方法是通过执行链接过程的实用程序静态方法：

public static <A, I, R> Service<A, R> link(final Service<A, I> s1, final Service<I, R> s2) {
    return new Service<A, R>() {
        @Override
        public R run(A a) throws Exception {
            I intermediate = s1.run(a);
            return s2.run(intermediate);
        }
    };
}
4

3 回答 3

4

你不能有一个泛型类型X，它是你的类的一部分（不是为每个方法调用重新选择）而不是它的声明的一部分。

当然，您可以隐藏不安全的强制转换并确保您的程序可以工作，但在 Java 类型系统的限制下，这实际上是您仅有的两个选择。

不过，我会做的不是提供Link构造函数，而是提供静态工厂方法

public static <A, X, R> Service<A, R> link(Service<A, X> s1, Service<X, R> s2) {
  return new Link<A, X, R>(s1, s2);
}

...确保X自动推断并且永远不会逃脱。

于 2012-12-14T17:19:27.087 回答
1

为了获得更好的协方​​差，您可以像这样调整上述答案：

public class Link <F, X, T>  implements Service <F, T> {
    private final Service<F, ? extends X> from;
    private final Service <X, ? extends T> to;

    public Link(Service <F, ? extends X> from, Service <X, ? extends T> to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public T run (F input) {
        return to.run (from.run (input));
    }
}
于 2012-12-14T20:06:17.387 回答
0

这将起作用：

public class Link<A, R, X> implements Service<A, R> {

    private Service<A, X> s1; 
    private Service<X, R> s2; 

    public Link(Service<A, X> s1, Service<X, R> s2) {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public R run(A a) {
       return s2.run(s1.run(a));
    }
}
于 2012-12-14T17:39:36.273 回答