Generics and Parameterized Constructors

Question

This is an extension of this previous question about parameterized methods. I am reading the same book. After the example in the previous question, the author improves the

BinaryTree<T extends Comparable<? super T>>

class yet again (and he really does this time around) by adding the following constructor

public  <E extends T> BinaryTree(E[] items) {
    for(E item : items) {
        add(item);
}

In the spirit of the previous question I tried this constructor instead:

public BinaryTree(T[] items) {
    for(T item : items) {
        add(item);
    }
}

and the example code does not compile with my constructor:

public static void main(String[] args) {
    Manager[] managers = { new Manager("Jane", 1), new Manager("Joe", 3), new Manager("Freda", 3), new Manager("Bert", 2), new Manager("Ann", 2), new Manager("Dave", 2) };
    BinaryTree<Person> people = new BinaryTree<>(managers);
}

What is this difference between changing the add() method in the previous question and changing this constructor? Why can't I pass a subtype of T in my constructor?

irreputable · Accepted Answer · 2013-02-27 02:38:57Z

2

For the 2nd constructor, when compiler sees

new BinaryTree<>(managers)

it needs to infer T for the <>. In this case, inference is based on managers: T[]=Manager[] => T=Manager.

Therefore the expression yields a BinaryTree<Manager>, which cannot be assigned to BinaryTree<Person>.

Two workarounds:

new BinaryTree<Person>(managers);

new BinaryTree((Person[])managers);

For the 1st constructor

<E extends T> BinaryTree(E[] items)

we have two things to infer now, E and T, in expression new BinaryTree<>(managers)

Now E=Manager is inferred; however T is not inferred yet. The compiler then looks at the target type Binary<Person>, which helps to infer that T=Person.

Java type inference is quite messy. Why would any programmer care to learn what I have just described? The lesson is, when in doubt, supply type arguments explicitly.

Between the two constructors, I would definitely choose BinaryTree(T[] items). The E version is just more complexity without benefits (though it happens to work better for this particular example)

edited Feb 27, 2013 at 2:38

answered Feb 27, 2013 at 2:14

irreputable

45.6k9 gold badges70 silver badges94 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Steve M Over a year ago

This all makes sense, thanks. So I guess there is not much of point in using <E extends T> BinaryTree(E[] items)

irreputable Over a year ago

There's no point, since the T[] arg would accept any X[] where X is subtype of T. Note this won't work for List. If we want to accept any List<X> where X is subtype of T, we need List<? extends T> as the arg type.

Collectives™ on Stack Overflow

Generics and Parameterized Constructors

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related