java - 在不指定类类型参数的情况下强制类字段为相同的泛型类型

Question

考虑一个对象，该对象生成由另一个对象使用以生成结果的数据。流程封装在一个类中，中间数据不相关。

在下面的例子中，这个过程发生在构造上，没有问题。构造函数上的类型参数确保兼容的消费者/生产者。

public class ProduceAndConsume {
    public interface Producer<T> {
        T produce();
    }
    public interface Consumer<V> {
        void consume(V data);
    }

    public <IntermediateType> ProduceAndConsume(Producer<? extends IntermediateType> producer, Consumer<IntermediateType> consumer) {
        consumer.consume(producer.produce());
    }

    ...

}

如果我希望存储对生产者/消费者的引用并在以后进行处理，那么代码将变为:

public class ProduceAndConsume<IntermediateType> {
    public interface Producer<T> {
        T produce();
    }
    public interface Consumer<V> {
        void consume(V data);
    }

    private Producer<? extends IntermediateType> producer;
    private Consumer<IntermediateType> consumer;

    public ProduceAndConsume(Producer<? extends IntermediateType> producer, Consumer<IntermediateType> consumer) {
        this.producer = producer;
        this.consumer = consumer;
    }

    ...

    private void doLater() {
        consumer.consume(producer.produce());
    }
 }

这向类引入了一个泛型类型参数，并强制在任何实现中指定它。

我的问题是，有什么办法可以避免这种情况吗？中间数据类型不由此类生成、存储或使用，并且与该类的用户无关。假设可以在某处指定 IntermediateType 类型参数，编译器拥有强制类型一致性所需的所有信息。

请注意，这是一个简化的示例，实际类会在构造后的某个时间异步并定期运行处理。

Answer 1

将生产者和消费者存储在具有类型变量的内部类中:

public class ProduceAndConsume {
  private class Inner<IntermediateType> {
    private Producer<? extends IntermediateType> producer;
    private Consumer<IntermediateType> consumer;

    // Constructor omitted.

    private void doLater() {
      consumer.consume(producer.produce());
    }
  }

  private final Inner<?> inner;

  public <IntermediateType> ProduceAndConsume(Producer<? extends IntermediateType> producer, Consumer<IntermediateType> consumer) {
    this.inner = new Inner<>(producer, consumer);
  }

  private void doLater() { // Or just invoke inner.doLater() directly.
    inner.doLater();  
  }
}

通过这种方式，您强制生产者和消费者在您稍后需要使用它们时相关，但之后您不需要在 ProduceAndConsume 实例中使用该类型信息。

Producer<String> stringProducer = ...;
Consumer<Object> objConsumer = ...;

// No externally-visible type variables.
ProduceAndConsume pac1 = new ProduceAndConsume(stringProducer, objConsumer);

但是编译器强制生产者和消费者的兼容性:

Consumer<Integer> integerConsumer = ...;
// Compiler error.
ProduceAndConsume pac2 = new ProduceAndConsume(stringProducer, integerConsumer);