Jak utworzyć klasę Java, która implementuje jeden interfejs z dwoma rodzajami generycznymi?

Question

Mam rodzajowego interfejsu

public interface Consumer<E> { 
    public void consume(E e); 
} 

Mam klasy, która pobiera dwa typy obiektów, więc chciałbym zrobić coś takiego:

public class TwoTypesConsumer implements Consumer<Tomato>, Consumer<Apple> 
{ 
    public void consume(Tomato t) { ..... } 
    public void consume(Apple a) { ...... } 
} 

Widocznie nie mogę tego zrobić.

Mogę oczywiście zrealizować wysyłkę samodzielnie, np.

public class TwoTypesConsumer implements Consumer<Object> { 
    public void consume(Object o) { 
     if (o instanceof Tomato) { ..... } 
     else if (o instanceof Apple) { ..... } 
     else { throw new IllegalArgumentException(...) } 
    } 
} 

Ale szukam w czasie kompilacji typu kontroli i wysyłki rozwiązanie, które zapewni rodzajowych.

Najlepszym rozwiązaniem, jakie mogę wymyślić, jest zdefiniowanie oddzielnych interfejsów, np.

public interface AppleConsumer { 
    public void consume(Apple a); 
} 

Funkcjonalnie to rozwiązanie jest OK, jak sądzę. To po prostu gadatliwe i brzydkie.

Wszelkie pomysły?

Answer 1

Rozważmy enkapsulacji:

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) { ..... } 
    } 
} 

Jeśli tworzenia tych statycznych klas wewnętrznych przeszkadza, można użyć anonimowego klasy:

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

Answer 2

Z powodu usunięcia typu nie można dwukrotnie zaimplementować tego samego interfejsu (z innymi parametrami typu).

Answer 3

Przynajmniej można zrobić małą poprawę swojej realizacji wysyłki wykonując coś jak następuje:

public class TwoTypesConsumer implements Consumer<Fruit> { 

Fruit bycia przodkiem Pomidor i Apple.

Answer 4

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

Wymownym wymaganiem pytania było Consumer<Tomato> i Consumer<Apple> obiektów, które współdzielą stan. Potrzeba obiektów Consumer<Tomato>, Consumer<Apple> pochodzi z innych metod, które oczekują tych parametrów jako parametrów. Potrzebuję jednej klasy, aby zaimplementować je zarówno w celu współdzielenia państwa.

Założeniem Steve'a było użycie dwóch klas wewnętrznych, z których każda implementuje inny rodzajowy.

Ta wersja dodaje obiekty pobierające dla obiektów implementujących interfejs klienta, które można następnie przekazać innym metodom oczekującym na nie.

Answer 5

po prostu natknąłem się na to. To po prostu się stało, że miałem ten sam problem, ale rozwiązać go w inny sposób: właśnie stworzył nowy interfejs podobny do tego

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

Niestety, jest to uważane za Consumer<A> a nie jako Consumer<B> wbrew wszelkiej logice .Więc trzeba stworzyć mały zasilacz dla drugiego konsumenta jak to wewnątrz 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 Consumer<A> jest potrzebna, można po prostu przejść this, a jeśli Consumer<B> potrzebna jest po prostu przekazać consumerAdapter

Answer 6

Nie możesz wykonaj to bezpośrednio w jednej klasie, ponieważ definicja klasy poniżej nie może zostać skompilowana z powodu usunięcia typów ogólnych i zduplikowania deklaracji interfejsu.

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

Każde inne rozwiązanie do pakowania takie same zużywają operacje w jednej klasie wymaga, aby określić swoją klasę jako:

class TwoTypesConsumer { ... } 

który jest bezcelowe, jak trzeba powtarzać/powielać definicję obu operacji i nie będzie odwoływać się z interfejsu. IMHO robi to źle i powielam kod, którego staram się unikać.

Może to być również wskaźnik, że w jednej klasie jest zbyt duża odpowiedzialność za pochłonięcie 2 różnych przedmiotów (jeśli nie są połączone).

Jednak to, co robię i co można zrobić, to dodać wyraźny obiekt fabryczny stworzyć podłączonych odbiorników w następujący sposób:

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

Jeśli w rzeczywistości te typy są naprawdę połączony (związane) potem polecam utworzyć wdrożenie 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 fabryka wie obie implementacje, istnieje wspólny stan (jeśli to konieczne) i można powrócić bardziej powiązanych z konsumentów w razie potrzeby. Nie ma powtarzania deklaracji metody konsumowania, która nie pochodzi z interfejsu.

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

Wadą tego rozwiązania jest to klasa wyższa złożoność (nawet jeśli może to być jeden plik Java) i dostęp do spożywania metoda trzeba jeszcze jedną rozmowę więc zamiast:

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

masz:

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

Podsumowując można określić 2 konsumentom generycznych w jednej klasie najwyższego poziomu za pomocą 2 klas wewnętrznych, ale w przypadku wywoływania trzeba się najpierw odniesienie do odpowiednich realizacji konsument, ponieważ nie może to być po prostu jeden obiekt konsumencki.