Quiero crear el siguiente patrón de estrategia combinado con Factory, pero quiero que sea de tipo seguro. He hecho lo siguiente hasta ahora:

public interface Parser<T> {

    public Collection<T> parse(ResultSet resultSet);

}


public class AParser implements Parser<String> {

    @Override
    public Collection<String> parse(ResultSet resultSet) {
             //perform parsing, get collection
        Collection<String> cl = performParsing(resultSet); //local private method
        return cl;
    }
}

public class ParserFactory {

    public enum ParserType {
        APARSER
    }


    public static <T> Parser<T> createParser(ParserType parserType) {


        Parser<?> parser = null;
        switch (parserType) {
        case APARSER:
            parser = new AParser();
            break;
        }
            //unchecked cast happens here
        return (Parser<T>) parser;
    }
}


public class Context {

      public <T> Collection<T> getResults(String query, ParserType parserType) {
          ResultSet resultSet() = getResultSet(query); //local private method
          Parser p = ParserFactory.createParser(parserType);
          Collection<T> results = p.parse(resultSet)
      }

}

En general, cualquier cosa que intente, en algún lugar tendré un elenco sin control. ¿Alguien tiene una idea de cómo puedo refactorizar el código para que sea seguro?

Comprobando Java efectivo también me topé con este patrón:

public final class ParserFactory {

    private ParserFactory() {

    }

    private static class AParser implements Parser<String> {
        @Override
        public Collection<String> parse(ResultSet resultSet) {
            //...
            return new ArrayList<>();
        }
    }

    public static final Parser<String> APARSER = new AParser();

}

Así que ahora puedo usar como Ingo sugirió.

public <T> Collection<T> getResults(String query, Parser<T> p)

como

getResults("query", ParserFactory.APARSER);

¿O sería mejor con enumeraciones?