0

これは試しているサンプルプログラムです。

私はアイテムを扱っています - シングルまたはマルチ

public interface IItem<T> { 
    T getContents();    
}

/** An item that holds a Map and uses it for something  */
public class SingleItem implements IItem<Map<String,String>> {
    . . . . .
}

/** An item that holds a List of maps and uses it for something  */
public class MultiItem implements IItem<List<Map<String,String>>> {
    . . . . .
}

SingleItems または MultiItems を生成できるプロデューサー

public interface IProducer<T> { 
    T produce();
}

public class SingleItemProducer implements IProducer<SingleItem> {

    @Override
    public SingleItem produce() {
        return new SingleItem(...);
    }
}

public class MultiItemProducer implements IProducer<MultiItem> {
    . . . . . 
    . . . . .
}

SingleItems または MultiItems を消費できるコンシューマ

public interface IConsumer<T> {
    void consume(T item);
}

public class SingleItemConsumer implements IConsumer<SingleItem> {

    @Override
    public void consume(SingleItem item) {  
        System.out.println(item.getContents());
    }
}

public class MultiItemConsumer implements IConsumer<MultiItem> {
    . . . . .
    . . . . .     
}

プロデューサーとコンシューマーを使用して作業を完了するプロセッサー。

public interface IProcessor<T> {
    void process();
    void process(T item);
}

/** A generic processor that should be able to work with any type of consumer or producer */
public class GenericItemProcessor implements IProcessor<IItem<? extends Object>> {

    IProducer<IItem<? extends Object>> producer;
    IConsumer<IItem<? extends Object>> consumer;

    public GenericItemProcessor (IProducer<IItem<? extends Object>> p, IConsumer<IItem<? extends Object>> c) {
        this.producer = p;
        this.consumer = c;
    }

    @Override
    public void process() {
        IItem<? extends Object> item = null;
        // As long the producer produces items, keep processing them
        while ((item = producer.produce()) != null) {
            this.process(item);
        }
    }

    @Override
    public void process(IItem<? extends Object> item) {
        consumer.consume(item);
    }
}

そして、メインプログラムでこれを試すと、

IProducer<SingleItem> producer = new SingleItemProducer();
IConsumer<SingleItem> consumer= new SingleItemConsumer();
IProcessor<IItem<? extends Object>> processor = new GenericItemProcessor(producer, consumer);

最後の課題ができませんと表示されます。

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    The constructor GenericItemProcessor(IProducer<SingleItem>, IConsumer<SingleItem>) is undefined

もちろん、これは機能しますが、

IProcessor<SingleItem> processor = new GenericItemProcessor(producer, consumer);

IItem<? extends Object>のすべての出現箇所をSingleIteminsideに置き換えるとGenericItemProcessor。

しかし、それに関する問題は、各項目タイプを処理するプロセッサを作成する必要があることです。これは、汎用の「型指定された」プロセッサを持つ目的を無効にするように見えます。

ここで明らかな何かが欠けているかもしれませんが、どうすればこれを正しく行うことができますか? アドバイスをいただければ幸いです。

4

1 に答える 1

1

ジェネリックの使用法はGenericItemProcessor複雑すぎると思います。プロセッサ内のコードは、プロセッサがIItemオブジェクトを生成するという事実を使用しないため、ジェネリック型を にバインドする必要はありませんIItem<? extends Object>。

/** A generic processor that should be able to work with any type of consumer or producer */
public class GenericProcessor<T> implements IProcessor<T> {

    IProducer<? extends T> producer;
    IConsumer<? super T> consumer;

    public GenericProcessor(IProducer<? extends T> p, IConsumer<? super T> c) {
        this.producer = p;
        this.consumer = c;
    }

    @Override
    public void process() {
        T item = null;
        // As long the producer produces items, keep processing them
        while ((item = producer.produce()) != null) {
            this.process(item);
        }
    }

    @Override
    public void process(T item) {
        consumer.consume(item);
    }
}

したがって、このコードは問題ありません。

IProducer<SingleItem> producer = new SingleItemProducer();
IConsumer<SingleItem> consumer = new SingleItemConsumer();
IProcessor<SingleItem> processor = new GenericProcessor<SingleItem>(
    producer, consumer);

それとは別に、これにより、オブジェクトを生成/消費しない場合でも、プロデューサー/コンシューマーを処理できるようになるため、プロセッサがさらに汎用的になりIItemます。? extends Tプロデューサーと? super Tコンシューマーの の使用法に注意してください。そのため、特定のタイプのサブクラスのインスタンスを生成するすべてのプロデューサーを、同じタイプのスーパー クラスのインスタンスを受け入れるコンシューマーに「接続」できます。

IProducer<Integer> producer = new IntegerProducer();
IConsumer<Object> consumer = new ObjectConsumer();
IProcessor<Number> processor = new GenericProcessor<Number>(
    producer, consumer);
于 2013-11-09T23:11:15.560 に答える