Jak stworzyć klasę Javy, która implementuje jeden interfejs z dwoma typami generycznymi?

Z powodu kasowania typu nie można zaimplementować tego samego interfejsu dwa razy (z różnymi parametrami typu).

Oto możliwe rozwiązanie oparte na 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);
            }
        }
    }
}

Dorozumianym wymogiem pytania były Consumer<Tomato> i Consumer<Apple> obiekty, które dzielą stan. Potrzeba obiektów Consumer<Tomato>, Consumer<Apple> pochodzi z innych metod, które oczekują ich jako parametrów. Potrzebuję jednej klasy, aby zaimplementować je obie, aby dzielić stan.

Ta wersja dodaje gettery dla obiektów, które implementują interfejs użytkownika, który następnie może być przekazywany innym oczekiwanym przez niego metodom.

Możesz przynajmniej poprawić swoją implementację wysyłania, wykonując coś w stylu:

public class TwoTypesConsumer implements Consumer<Fruit> {

Natknąłem się na to. Tak się złożyło, że miałem ten sam Problem, ale rozwiązałem go w inny sposób: Właśnie stworzyłem nowy interfejs, taki jak ten

public interface TwoTypesConsumer<A,B> extends Consumer<A>{
    public void consume(B b);
}

Niestety, jest to uważane za Consumer<A>, a nie za Consumer<B> wbrew wszelkiej logice. Więc musisz stworzyć mały Adapter dla drugiego konsumenta, jak ten wewnątrz swojej klasy

public class ConsumeHandler implements TwoTypeConsumer<A,B>{

    private final Consumer<B> consumerAdapter = new Consumer<B>(){
        public void consume(B b){
            ConsumeHandler.this.consume(B b);
        }
    };

    public void consume(A a){ //...
    }
    public void conusme(B b){ //...
    }
}

Jeśli potrzebne jest Consumer<A>, możesz po prostu przekazać this, a jeśli Consumer<B> jest potrzebne po prostu przekazać consumerAdapter

Nie można tego zrobić bezpośrednio w jednej klasie, ponieważ poniższa definicja klasy nie może być skompilowana z powodu usunięcia typów ogólnych i zduplikowanej deklaracji interfejsu.

class TwoTypesConsumer implements Consumer<Apple>, Consumer<Tomato> { 
 // cannot compile
 ...
}

Każde inne rozwiązanie do pakowania tych samych operacji w jednej klasie wymaga zdefiniowania klasy jako:

class TwoTypesConsumer { ... }

Co jest bezcelowe, ponieważ musisz powtórzyć / powielić definicję obu operacji i nie będą one odwoływane z interfejsu. IMHO robienie tego to kiepskie małe i duplikowanie kodu które Staram się unikać.

Może to być również wskaźnikiem, że w jednej klasie jest zbyt wiele odpowiedzialności, aby konsumować 2 różne obiekty (jeśli nie są one połączone).

Jednak to, co robię i co możesz zrobić, to dodać explicit Factory object, aby utworzyć połączonych konsumentów w następujący sposób:

interface ConsumerFactory {
     Consumer<Apple> createAppleConsumer();
     Consumer<Tomato> createTomatoConsumer();
}

Jeśli w rzeczywistości te typy są naprawdę sprzężone (powiązane) to polecam stworzyć implementację w taki sposób:

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();
    }
}

Zaletą jest to, że Klasa factory zna obie implementacje, istnieje wspólny stan (w razie potrzeby) i w razie potrzeby można zwrócić więcej sprzężonych konsumentów. Nie ma powtarzalnej deklaracji użycia metody, która nie pochodzi z interfejsu.

Należy pamiętać, że każdy konsument może być niezależną (nadal prywatną) klasą, jeśli nie są całkowicie spokrewnieni.

Minusem tego rozwiązania jest wyższa złożoność klasy (nawet jeśli może to być jeden plik java) i aby uzyskać dostęp do metody consume, potrzebujesz jeszcze jednego wywołania więc zamiast:

twoTypesConsumer.consume(apple)
twoTypesConsumer.consume(tomato)

Masz:

twoTypesConsumerFactory.createAppleConsumer().consume(apple);
twoTypesConsumerFactory.createTomatoConsumer().consume(tomato);

Podsumowując, możesz zdefiniować 2 generycznych konsumentów w jednej klasie najwyższego poziomu, używając 2 wewnętrznych klas, ale w przypadku wywołania musisz najpierw uzyskać odniesienie do odpowiedniego implementującego konsumenta, ponieważ nie może to być po prostu jeden obiekt konsumencki.