使用泛型：使用泛型中的父级和子级值实例化泛型类的对象

Question

The question from the exam states: Write a class called Registration which can store variables of type T, where T can be replaced with String, Person, Student, etc.. It should be possible to instantiate Registration as follows:

Registration<String> r1 = new Registration<String>();
Registration<Person> r2 = new Registration<Student>();

I am unable to figure out how to write the declaration for the generics part of the class header. Below I have given the Registration class. To note, the class Student inherits the Person class.

import java.util.List;
import java.util.ArrayList;
public class Registration<T extends Person> //I believe my issue is here{
private T [] roster;
private List<T> waitList;
private static int rosterCount;
private T lastInstance;

public Registration () {
    roster =  (T[]) new Object[100];
    waitList = new ArrayList<>();
    rosterCount = 0;
    lastInstance = null;
}

public void addIndex (T t) {
    if (rosterCount>=100) {
        waitList.add(t);
    }
    else {
        roster [rosterCount] = t;
        rosterCount++;
    }
    lastInstance = t;
}

public T getLastInstance() {
    return lastInstance;
}

public int getRosterCount() {
    return rosterCount;
}

public int getWaitListCount() {
    return waitList.size();
}
}

**Taken from Uoft CSC207 Aug2017 Exam

Answer 1

If Registration has to be generic enough to accept any type, eg. String , then you should declare it as:

class Registration<T> {
    private T[] roster;
    ...
    public Registration (Class<T> clazz) {
        roster = (T[])Array.newInstance(clazz, 100);
    }
    ...
} 

Answer 2

The following snippet would do, note that

Registration<Person> r2 = new Registration<Student>(); 

is not possible so rewritten at the bottom.

    static class Person  {}
    static class Student extends Person {}

    static class Registration<T> {
        private T[] roster;
        private List<T> waitList;
        static int rosterCount;
        private T lastInstance;

        public Registration() {
            roster =  (T[]) new Object[100]; ;
            waitList = new ArrayList<T>();
        }
    }

    public static void main(String[] args) {
        Registration<String> r1 = new Registration<String>();
        Registration<? extends Person> r2 = new Registration<Student>();
    }

Answer 3

The question is wrong or you've copied it incorrectly somehow. There exists no such class declaration that can satisfy this instantiation.

Registration<Person> r = new Registration<Student>();

This is because by placing the object in r you allow its constraints to be violated.

For instance:

Registration<Student> r0 = new Registration<Student>();
r0.addIndex(new Student());
Student s0 = r0.getLastInstance(); // returns a student instance 
r0. addIndex(new Person());  // error, person is not a subclass of student 

Registration<Person> r1 = r0; // error, but we will pretend it's allowed - you could force it with a cast 
r1.addIndex(new Person()); // this is cool, but what happens to the underlying object? 
Person p = r1.getLastInstance(); // this is fine, just like before 
Student s1 = r0.getLastInstance(); // error, returns a person instance!

This happens because r0 and r1 are the same object and so have the same last instance - a Person instance. But the generic type of r0 promises that it's return type is Student. That is why you cannot assign generics in the same way you can with normal types. This is why you wildcards have their place. It means the generic type can only be used to return things of that type eg. <? extends Person> <? extends Person> , but not pass them as parameters. Or it means that the generic type can only be passed things of that type <? super Student> <? super Student> , but not return them.