2つのジェネリック型を持つ1つのインターフェースを実装するJavaクラスを作成する方法は？

汎用インターフェースがあります

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

2つのタイプのオブジェクトを使用するクラスがあるので、次のような処理を行います。

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

型消去のため、同じインターフェイスを（異なる型パラメーターで）2回実装することはできません。

スティーブマクロードの解決策に基づく可能な解決策を次に示します。

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>オブジェクトの必要性は、これらをパラメーターとして期待する他のメソッドから生じます。状態を共有するには、両方を実装する1つのクラスが必要です。

Steveのアイデアは、2つの内部クラスを使用し、それぞれが異なるジェネリック型を実装することでした。

このバージョンは、Consumerインターフェースを実装するオブジェクトのゲッターを追加し、それらを期待する他のメソッドに渡すことができます。

少なくとも、次のようなことを行うことで、ディスパッチの実装に小さな改善を加えることができます。

public class TwoTypesConsumer implements Consumer<Fruit> {

フルーツはトマトとアップルの祖先です。

ちょうどこれにつまずいた。たまたま、同じ問題が発生しましたが、別の方法で解決しました。このような新しいインターフェースを作成しただけです。

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

残念ながら、これはすべてのロジックに対するものではなく、すべてのロジックに対するものではConsumer<A>ありませんConsumer<B>。したがって、クラス内にこのような2番目のコンシューマ用の小さなアダプタを作成する必要があります

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

a Consumer<A>が必要な場合は単に渡すことができthis、Consumer<B>必要な場合は単に渡すconsumerAdapter

ジェネリック型の消去とインターフェイス宣言の重複により、以下のクラス定義をコンパイルできないため、これを1つのクラスで直接行うことはできません。

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

同じ消費操作を1つのクラスにパックする他のソリューションでは、クラスを次のように定義する必要があります。

class TwoTypesConsumer { ... }

両方の操作の定義を繰り返す/複製する必要があり、インターフェースから参照されないので、これは無意味です。これを行う私見は、私が回避しようとしている悪い小さなコードの重複です。

これは、1つのクラスで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();
    }
}

利点は、ファクトリクラスが両方の実装を認識し、共有状態があり（必要な場合）、必要に応じてより多くの結合されたコンシューマを返すことができることです。インターフェースから派生していない繰り返しの消費メソッド宣言はありません。

それらが完全に関連していない場合、各コンシューマは独立した（まだプライベート）クラスである可能性があることに注意してください。

そのソリューションの欠点は、クラスが複雑になること（これが1つのJavaファイルである場合でも）で、消費メソッドにアクセスするには、次の代わりにもう1回呼び出す必要があります。

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

あなたが持っている：

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

要約すると、 2つの内部クラスを使用して1つの最上位クラスで2つの汎用コンシューマを定義できますが、呼び出しの場合は、適切な実装コンシューマへの参照を最初に取得する必要があります。これは単なる1つのコンシューマオブジェクトではないためです。

Functionalスタイルでは、インターフェースを実装せずにこれを行うのは非常に簡単です。また、コンパイル時の型チェックも行います。

エンティティーを消費するための機能インターフェース

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

それがあなたが探しているものだと思います。

次の出力が得られます。

トマト消費！

私はリンゴを食べます

文字列が消費されました！