Chcę utworzyć następujący wzór strategii w połączeniu z Factory, ale chcę, aby był bezpieczny. Do tej pory wykonałem następujące czynności:

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

}

Generalnie cokolwiek spróbuję, gdzieś będę miał niekontrolowaną obsadę. Czy ktoś ma pomysł, w jaki sposób mogę zmienić kod, aby był bezpieczny?

Sprawdzając efektywną Javę natknąłem się również na ten wzór:

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

}

Teraz mogę użyć, jak zasugerował Ingo

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

tak jak

getResults("query", ParserFactory.APARSER);

A może byłoby lepiej z enumami?