Як зробити клас Java, який реалізує один інтерфейс з двома загальними типами?

У мене є загальний інтерфейс

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

У мене є клас, який споживає два типи об'єктів, тому я хотів би зробити щось на кшталт:

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

Мабуть, я не можу цього зробити.

Я, звичайно, можу реалізувати відправлення самостійно, наприклад

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

Але я шукаю рішення для перевірки та диспетчеризації компіляційного часу, яке надає генерика.

Найкращим рішенням, про який я можу придумати, є визначення окремих інтерфейсів, наприклад

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

Функціонально це рішення гаразд, я думаю. Це просто багатослівно і некрасиво.

Будь-які ідеї?

Розглянемо інкапсуляцію:

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

Якщо створення цих статичних внутрішніх класів вас непокоїть, ви можете використовувати анонімні класи:

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

Через стирання типу ви не можете двічі реалізувати один і той же інтерфейс (з різними параметрами типу).

Ось можливе рішення, засноване на одному зі Стіва Маклеода :

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

Неявна вимога питання була Consumer<Tomato>і Consumer<Apple>об'єктами, які поділяють стан. Потреба в Consumer<Tomato>, Consumer<Apple>об'єктах походить від інших методів, які очікують їх як параметрів. Мені потрібен один клас реалізувати їх обох, щоб поділитися станом.

Ідея Стіва полягала у використанні двох внутрішніх класів, кожен із яких реалізував різний родовий тип.

Ця версія додає гетьтери для об’єктів, що реалізують споживчий інтерфейс, які потім можуть бути передані іншим методам, які очікують їх.

Принаймні, ви можете зробити невелике покращення щодо вашої реалізації відправки, зробивши щось на зразок наступного:

public class TwoTypesConsumer implements Consumer<Fruit> {

Фрукт є родоначальником томата та яблука.

просто натрапили на це. Просто сталося, що у мене була та сама проблема, але я вирішив її по-іншому: я просто створив новий інтерфейс, як цей

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

на жаль, це вважається як Consumer<A>і НЕ, як Consumer<B>проти всієї Логіки. Таким чином, ви повинні створити невеликий адаптер для другого споживача, як цей у вашому класі

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

якщо Consumer<A>потрібен а, ви можете просто пройти this, а якщо Consumer<B>потрібно просто пройтиconsumerAdapter

Це неможливо зробити безпосередньо в одному класі, оскільки визначення класу нижче не може бути скомпільовано через стирання загальних типів та дублювання декларації інтерфейсу.

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

Будь-яке інше рішення для пакування одних і тих же споживчих операцій в одному класі вимагає визначити свій клас як:

class TwoTypesConsumer { ... }

що безглуздо, оскільки вам потрібно повторювати / дублювати визначення обох операцій, і вони не будуть посилатися на інтерфейс. ІМХО, що робить це, є поганим малим копіюванням коду, якого я намагаюся уникати.

Це може бути показником також того, що в одному класі є занадто велика відповідальність за споживання двох різних об'єктів (якщо вони не пов'язані між собою).

Однак те, що я роблю, і те, що ви можете зробити, - це додати явний заводський об’єкт для створення підключених споживачів наступним чином:

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-файл), а для доступу до способу споживання потрібен ще один виклик, а не:

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

ти маєш:

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

Підсумовуючи, ви можете визначити 2 загальних споживача в одному класі найвищого рівня, використовуючи 2 внутрішніх класи, але у випадку виклику вам потрібно спочатку звернутися до відповідного споживача, що впроваджує, оскільки це не може бути просто одним об’єктом споживача.

У функціональному стилі це зробити досить просто, не реалізуючи інтерфейс, а також він робить перевірку типу компіляції часу.

Наш функціональний інтерфейс для споживання сутності

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

наш менеджер обробляє та споживає організацію належним чином

public class Manager {
    public <E> void process(Consumer<E> consumer, E entity) {
        consumer.consume(entity);
    }

    public void consume(Tomato t) {
        // Consume Tomato
    }

    public void consume(Apple a) {
        // Consume Apple
    }

    public void test() {
        process(this::consume, new Tomato());
        process(this::consume, new Apple());
    }
}

Ще одна альтернатива, щоб уникнути використання більшої кількості класів. (наприклад, використовуючи java8 +)

// Mappable.java
public interface Mappable<M> {
    M mapTo(M mappableEntity);
}

// TwoMappables.java
public interface TwoMappables {
    default Mappable<A> mapableA() {
         return new MappableA();
    }

    default Mappable<B> mapableB() {
         return new MappableB();
    }

    class MappableA implements Mappable<A> {}
    class MappableB implements Mappable<B> {}
}

// Something.java
public class Something implements TwoMappables {
    // ... business logic ...
    mapableA().mapTo(A);
    mapableB().mapTo(B);
}

Вибачте за відповіді на старі запитання, але мені дуже подобається! Спробуйте цей варіант:

public class MegaConsumer implements Consumer<Object> {

  Map<Class, Consumer> consumersMap = new HashMap<>();
  Consumer<Object> baseConsumer = getConsumerFor(Object.class);

  public static void main(String[] args) {
    MegaConsumer megaConsumer = new MegaConsumer();
    
    //You can load your customed consumers
    megaConsumer.loadConsumerInMapFor(Tomato.class);
    megaConsumer.consumersMap.put(Apple.class, new Consumer<Apple>() {
        @Override
        public void consume(Apple e) {
            System.out.println("I eat an " + e.getClass().getSimpleName());
        }
    });
    
    //You can consume whatever
    megaConsumer.consume(new Tomato());
    megaConsumer.consume(new Apple());
    megaConsumer.consume("Other class");
  }

  @Override
  public void consume(Object e) {
    Consumer consumer = consumersMap.get(e.getClass());
    if(consumer == null) // No custom consumer found
      consumer = baseConsumer;// Consuming with the default Consumer<Object>
    consumer.consume(e);
  }

  private static <T> Consumer<T> getConsumerFor(Class<T> someClass){
    return t -> System.out.println(t.getClass().getSimpleName() + " consumed!");
  }

  private <T> Consumer<T> loadConsumerInMapFor(Class<T> someClass){
    return consumersMap.put(someClass, getConsumerFor(someClass));
  }
}

Я думаю, що це те, що ти шукаєш.

Ви отримуєте цей вихід:

Помідор вживається!

Я їм яблуко

Рядок споживається!