Java generics software engineering design

Question

I have a class RabbitQueue which basically acts like a queue and implements my Pollable interface.

I also have a class SaveToDatabaseStrategy which implements my DataProcessingStrategy interface. This is designed following the strategy-pattern.

Now, my class InputHandler which implements my interface InputListener, contains an instance of the Pollable interface and one of the DataProcessingStrategy interface.

However, I don't want to set the Generic type (String) when I declare these two fields, since the Generic type depends on the implementation of this interface which is given later on.

How would you design this?

public interface Pollable<T> {
    T poll();
}

public class RabbitQueue implements Pollable<String> {
    // code..
}

public interface DataProcessingStrategy<T> {
    void processData(T t);
}

public class SaveToDatabaseStrategy<T> implements DataProcessingStrategy<T> {

    private Repository<T, ?> repo;

    public SaveToDatabaseStrategy(Repository<T, ?> repo) {
        this.repo = repo;
    }

    @Override
    public void processData(T data) {
        repo.create(data);
        System.out.printf("Received data of type %s: %s\n", data.getClass().getSimpleName(), data);
    }
}

public interface InputListener<T> {
    void inputReceived();
    void inputReceived(T t);
}

public class InputHandler implements InputListener<String> {

    private Pollable<String> queue;
    private DataProcessingStrategy<String> strategy;

    public InputHandler(String host, String queueName) throws IOException, TimeoutException {
        queue = new RabbitQueue(host, queueName, this);
    }

    public void setStrategy(DataProcessingStrategy strategy) {
        this.strategy = strategy;
    }

    @Override
    public void inputReceived() {
        System.out.println("Input received!");
        strategy.processData(queue.poll());
    }

    @Override
    public void inputReceived(String s) {
        System.out.println("Input received: " + s + "!");
        System.out.println("> " + queue.poll());
    }
}

Answer 1

You could add a type parameter to the InputHandler class.

public class InputHandler<T> implements InputListener<T> {

private Pollable<T> queue;
private DataProcessingStrategy<T> strategy;

public InputHandler(String host, String queueName) throws IOException, TimeoutException {
    queue = new RabbitQueue(host, queueName, this);
}

public void setStrategy(DataProcessingStrategy strategy) {
    this.strategy = strategy;
}

@Override
public void inputReceived() {
    System.out.println("Input received!");
    strategy.processData(queue.poll());
}

@Override
public void inputReceived(String s) {
    System.out.println("Input received: " + s + "!");
    System.out.println("> " + queue.poll().toString());
}
}

Then create a new object like

new InputHandler<String>(host, queueName)