Bir arabirimi iki genel türle uygulayan bir Java sınıfı nasıl yapılır?

Genel bir arayüzüm var

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

İki tür nesne tüketen bir sınıf var, bu yüzden şöyle bir şey yapmak istiyorum:

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

Görünüşe göre bunu yapamam.

Elbette gönderimi kendim uygulayabilirim, örn.

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

Ancak, jeneriklerin sağladığı derleme zamanı tür denetleme ve gönderme çözümünü arıyorum.

Düşünebileceğim en iyi çözüm, ayrı arayüzler tanımlamaktır, örn.

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

İşlevsel olarak, bu çözüm tamam, sanırım. Sadece ayrıntılı ve çirkin.

Herhangi bir fikir?

Kapsüllemeyi düşünün:

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

Bu statik iç sınıfları oluşturmak sizi rahatsız ediyorsa, anonim sınıfları kullanabilirsiniz:

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

Tür silme nedeniyle aynı arabirimi iki kez (farklı tür parametreleriyle) uygulayamazsınız.

İşte Steve McLeod'in çözümüne dayanan olası bir çözüm :

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

Sorunun örtük gereksinimi Consumer<Tomato>ve Consumer<Apple>durumu paylaşan nesnelerdi. Consumer<Tomato>, Consumer<Apple>Nesne ihtiyacı, bunları parametre olarak bekleyen diğer yöntemlerden gelir. Durumu paylaşmak için her ikisini de uygulamak için bir sınıfa ihtiyacım var.

Steve'in fikri, her biri farklı bir jenerik tip uygulayan iki iç sınıf kullanmaktı.

Bu sürüm, Tüketici arabirimini uygulayan nesneler için alıcılar ekler; bu, daha sonra onları bekleyen diğer yöntemlere aktarılabilir.

En azından, aşağıdakine benzer bir şey yaparak gönderim uygulamanızda küçük bir iyileştirme yapabilirsiniz:

public class TwoTypesConsumer implements Consumer<Fruit> {

Meyve domates ve elma atası olmak.

sadece tökezledi. Aynı problemi yaşadım, ama farklı bir şekilde çözdüm: Sadece böyle yeni bir Arayüz oluşturdum

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

ne yazık ki, bu tüm Mantık'a karşı olduğu gibi Consumer<A>DEĞİLDİR Consumer<B>. Bu nedenle, sınıfınızdaki ikinci tüketici için küçük bir Adaptör oluşturmanız gerekir.

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>gerekiyorsa, basitçe geçebilirsiniz thisve gerekirse Consumer<B>sadece geçconsumerAdapter

Genel sınıfların silinmesi ve yinelenen arabirim bildirimi nedeniyle aşağıdaki sınıf tanımı derlenemediğinden bunu doğrudan bir sınıfta yapamazsınız.

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

Aynı tüketme işlemlerini bir sınıfta paketlemek için başka herhangi bir çözüm, sınıfınızı şu şekilde tanımlamayı gerektirir:

class TwoTypesConsumer { ... }

her iki işlemin tanımını tekrarlamanız / çoğaltmanız gerektiğinden anlamsızdır ve arabirimden referans alınmaz. Bunu yaparken IMHO kaçınmaya çalışıyorum kötü bir küçük ve kod çoğaltma.

Bu aynı zamanda bir sınıfta 2 farklı nesneyi tüketmek için çok fazla sorumluluk bulunduğunun bir göstergesi olabilir (eşleşmemişlerse).

Ancak yaptığım ve yapabileceğiniz şey, bağlı tüketicileri aşağıdaki şekilde oluşturmak için açık fabrika nesnesi eklemektir:

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

Eğer gerçekte bu tipler gerçekten bağlıysa (ilgili) o zaman böyle bir uygulama yaratmanızı tavsiye ederim:

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

Avantajı, fabrika sınıfının her iki uygulamayı da bilmesidir, paylaşılan bir durum vardır (gerekirse) ve gerekirse daha fazla bağlı tüketici iade edebilirsiniz. Arabirimden türetilmeyen yinelenen bir tüketme yöntemi bildirimi yoktur.

Tamamen ilgili değilse, her bir tüketicinin bağımsız (hala özel) sınıf olabileceğini lütfen unutmayın.

Bu çözümün dezavantajı daha yüksek bir sınıf karmaşıklığıdır (bu bir java dosyası olsa bile) ve tüketme yöntemine erişmek için aşağıdakiler yerine bir çağrı daha yapmanız gerekir:

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

var:

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

Özetlemek gerekirse, 2 iç sınıf kullanarak bir üst düzey sınıfta 2 genel tüketici tanımlayabilirsiniz, ancak arama durumunda ilk olarak uygun uygulayıcı tüketiciye bir referans almanız gerekir, çünkü bu sadece bir tüketici nesnesi olamaz.

Fonksiyonel tarzda, arayüzü uygulamadan bunu yapmak oldukça kolaydır ve ayrıca zaman tipi kontrolünü derler.

Varlığı tüketmek için fonksiyonel arayüzümüz

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

yöneticimiz varlığı uygun şekilde işlemek ve tüketmek

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

Daha fazla sınıf kullanmaktan kaçınmak için başka bir alternatif. (java8 + kullanan örnek)

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

Eski soruları cevapladığım için üzgünüm, ama gerçekten çok seviyorum! Bu seçeneği deneyin:

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

Bence aradığınız şey bu.

Bu çıktıyı alırsınız:

Domates tükendi!

Bir elma yerim

Dize tüketildi!