使用泛型返回不止一种类型

Question

I am currently trying to refactor some of my code and have stumbled into a feature I haven't used before in Java related to Generics.

I am attempting to return an ArrayList<?> of a specific type based on the parameter passed into the method. The Parameter accepts an Enumeration that specifies the desired type of ArrayList<T> To return, something like this, however I am getting errors from the method prototype:

// Retrieves an ArrayList of questions available for a particular QuestionType
    public <T extends Question> ArrayList<T extends Question> getQuestions(QuestionType type) {
        switch (type) {
        case BASE_QUESTION:
            return mQuestions; // ArrayList<Question>

        case MULTIPLE_ANSWER_QUESTION:
        case MULTIPLE_CHOICE_QUESTION:
        case TRUE_FALSE_QUESTION:
            return mMultipleAnswerQuestions; // ArrayList<MultipleAnswerQuestion>

        case MATCHING_QUESTION:
            return mMatchingQuestions; // ArrayList<MatchingQuestion>

        case BLANK_QUESTION:
            return mBlankQuestions; // ArrayList<BlankQuestion>

        default:
            // TODO Perfect place to throw an exception
            Log.d(TAG, "Exception: Provided a non-existant QuestionType");
        }
    }

Additional Information: This method exists within a custom object that contains multiple ArrayList of Questions organised by their type. This method does not Exist within the SuperClass of the Question type.

// CLASS HIERARCHY
// SuperClass
Question

// SubClasses of Question
MultipleAnswerQuestion
MultipleChoiceQuestion
TrueFalseQuestion
MatchingQuestion
BlankQuestion

Can some explain to me how to prototype a method that achieves this task?

Thanks for your understanding and help.

Answer 1

Change your method signature to:

public ArrayList<? extends Question> getQuestions(QuestionType type) 

On a side note, you might want to just create an EnumMap to map your lists instead of doing a switch every time.

Answer 2

Those particular compilation errors you got were probably because the syntax error of declaring the bounds on T a second time prevented the compiler from recognizing ArrayList<T extends Question> as your return type. So if you either remove extends Question or change your return type to a bounded wildcard the compilation errors should go away.

In generic methods, you only specify bounds on the type parameter once -- when declaring them at the beginning of the method signature. In other words, just use ArrayList<T> as the return type instead of ArrayList<T extends Question> , because you already specified what the bounds were on T in the generic method.

So you'd end up with something like

public <T extends Question> ArrayList<T> getQuestions(QuestionType type) {
    ...
}

In addition, because you don't appear to actually use T in your method, it's probably a better idea to skip the generic method altogether and just use a bounded wildcard in your return value, like this:

public ArrayList<? extends Question> getQuestions(QuestionType type) {
    ...
}

Answer 3

The correct prototype is public <T extends Question> ArrayList<T> getQuestions(QuestionType type) or public ArrayList<? extends Question> getQuestions(QuestionType type) public ArrayList<? extends Question> getQuestions(QuestionType type)