Question

我有以下类结构：

public interface Incoming<P extends Processor> {
   void doSomething(P p);
}

public interface Processor<I extends Incoming> {
      void process(I i);
}

public class MyIncoming implements Incoming<MyProcessor>
{
   public void doSomething(MyProcessor p) { .. }
}

public class MyProcessor implements Processor<MyIncoming> {
 public void process(MyIncoming i) { .. }
}

现在在另一个类中，我传递一个MyIncoming实例，该实例应该初始化为doSomething（）中定义的处理器传递的类型？

请帮忙。

Answer 1

我在您的代码中看到的第一个问题是您使用的是原始类型Incoming和Processor。

public interface Incoming<P extends Processor> {
   void doSomething(P p);               ^^
}                               that is a raw type!

摆脱这些原始类型的一种方法是让Incoming和Processor都有两个类型参数，但它非常复杂。

public interface Incoming<I extends Incoming<I, P>, P extends Processor<I, P>> {
    void doSomething(P p);
}

public interface Processor<I extends Incoming<I, P>, P extends Processor<I, P>> {
    void process(I i);
}

现在回答你的实际问题。您已经说过，对于Incoming的每个具体实现，您都有Processor的特定实例，而对于t类型的变量Incoming，您希望成为能够找到该实例x并致电x.process(t);。我确信这可以用反射来完成，但我无法理解这一点。您可以将getProcessor作为Incoming的方法。

public interface Incoming<I extends Incoming<I, P>, P extends Processor<I, P>> {
    void doSomething(P p);
    P getProcessor();
}

现在你可以编写具体的实现。

public class MyIncoming implements Incoming<MyIncoming, MyProcessor>
{
    private static final MyProcessor PROCESSOR = new MyProcessor();

    @Override
    public void doSomething(MyProcessor p) { }

    @Override
    public MyProcessor getProcessor() { return PROCESSOR; }
}

public class MyProcessor implements Processor<MyIncoming, MyProcessor> {

    @Override
    public void process(MyIncoming i) { }
}

现在，如果你有一个通用类

class A<I extends Incoming<I, P>, P extends Processor<I, P>>

并且，在A内，您有i类型的变量I，您可以

i.getProcessor().process(i);

这很有效，但我个人认为TypeA<B extends TypeB> / TypeB<A extends TypeA>形式的循环依赖关系不必要地复杂化，而且这里的泛型实际上对你不利。如果你只是制作Incoming和Processor非通用接口并在必要时使用铸造，它可以保持你的理智。

如何找到方法参数的具体类

1 个答案: