How to make a Java class that implements one interface with two generic types?

Consider encapsulation:

public class TwoTypesConsumer {    private TomatoConsumer tomatoConsumer = new TomatoConsumer();    private AppleConsumer appleConsumer = new AppleConsumer();    public void consume(Tomato t) {         tomatoConsumer.consume(t);    }    public void consume(Apple a) {         appleConsumer.consume(a);    }    public static class TomatoConsumer implements Consumer<Tomato> {        public void consume(Tomato t) {  .....  }    }    public static class AppleConsumer implements Consumer<Apple> {        public void consume(Apple a) {  .....  }    }}

If creating these static inner classes bothers you, you can use anonymous classes:

public class TwoTypesConsumer {    private Consumer<Tomato> tomatoConsumer = new Consumer<Tomato>() {        public void consume(Tomato t) {        }    };    private Consumer<Apple> appleConsumer = new Consumer<Apple>() {        public void consume(Apple a) {        }    };    public void consume(Tomato t) {        tomatoConsumer.consume(t);    }    public void consume(Apple a) {        appleConsumer.consume(a);    }}

Because of type erasure you can't implement the same interface twice (with different type parameters).

Here's a possible solution based on Steve McLeod's one:

public class TwoTypesConsumer {    public void consumeTomato(Tomato t) {...}    public void consumeApple(Apple a) {...}    public Consumer<Tomato> getTomatoConsumer() {        return new Consumer<Tomato>() {            public void consume(Tomato t) {                consumeTomato(t);            }        }    }    public Consumer<Apple> getAppleConsumer() {        return new Consumer<Apple>() {            public void consume(Apple a) {                consumeApple(t);            }        }    }}

The implicit requirement of the question was Consumer<Tomato> and Consumer<Apple> objects that share state. The need for Consumer<Tomato>, Consumer<Apple> objects comes from other methods that expect these as parameters. I need one class the implement them both in order to share state.

Steve's idea was to use two inner classes, each implementing a different generic type.

This version adds getters for the objects that implement the Consumer interface, which can then be passed to other methods expecting them.