您不能直接在一个类中执行此操作，因为由于泛型类型的擦除和重复的接口声明，无法编译下面的类定义。
class TwoTypesConsumer implements Consumer<Apple>, Consumer<Tomato> {
// cannot compile
...
}
将相同的消费操作打包到一个类中的任何其他解决方案都需要将您的类定义为：
class TwoTypesConsumer { ... }
这是没有意义的，因为您需要重复/复制这两个操作的定义，并且不会从接口中引用它们。恕我直言，这样做是一个糟糕的小问题，我试图避免代码重复。
这也可能表明一个类中有太多责任来消耗 2 个不同的对象（如果它们没有耦合）。
但是，我正在做的以及您可以做的是添加显式工厂对象以通过以下方式创建连接的消费者：
interface ConsumerFactory {
Consumer<Apple> createAppleConsumer();
Consumer<Tomato> createTomatoConsumer();
}
如果实际上这些类型确实耦合（相关），那么我建议以这种方式创建一个实现：
class TwoTypesConsumerFactory {
// shared objects goes here
private class TomatoConsumer implements Consumer<Tomato> {
public void consume(Tomato tomato) {
// you can access shared objects here
}
}
private class AppleConsumer implements Consumer<Apple> {
public void consume(Apple apple) {
// you can access shared objects here
}
}
// It is really important to return generic Consumer<Apple> here
// instead of AppleConsumer. The classes should be rather private.
public Consumer<Apple> createAppleConsumer() {
return new AppleConsumer();
}
// ...and the same here
public Consumer<Tomato> createTomatoConsumer() {
return new TomatoConsumer();
}
}
优点是工厂类知道这两种实现，有一个共享状态（如果需要），如果需要，您可以返回更多耦合的消费者。没有不是从接口派生的重复消费方法声明。
请注意，如果每个消费者不完全相关，它们可能是独立的（仍然是私有的）类。
该解决方案的缺点是更高的类复杂性（即使这可以是一个 java 文件）并且要访问 consume 方法，您需要再调用一次，而不是：
twoTypesConsumer.consume(apple)
twoTypesConsumer.consume(tomato)
你有：
twoTypesConsumerFactory.createAppleConsumer().consume(apple);
twoTypesConsumerFactory.createTomatoConsumer().consume(tomato);
总而言之，您可以使用 2 个内部类在一个顶级类中定义2 个通用消费者，但在调用的情况下，您需要首先获得对适当实现消费者的引用，因为这不能只是一个消费者对象。