将Java泛型与通配符一起使用时，“类型不匹配”

Question

I have a strange problem using Generics in Java. Generics are quite new to me, but I think I understand the basics.

Please have a look at this piece of code:

private void drawQuadtreeBoxes_helper(QuadTree<?> node) {
    if (node == null)
        return;

    Vector3 min = node.bbox.min;
    Vector3 max = node.bbox.max;
    // Draw the boxes (...)

    if (node.hasChildren()) {
        Array<QuadTree<?>> children = node.getChildren(); // ERROR HERE
        for (QuadTree<?> child : children) {
            drawQuadtreeBoxes_helper(child);
        }
    }
}

Because the type of objects stored inside the quadtree-structure is not relevant for this method, I use a wildcard for the method signature, so that this method can be applied to all kinds of QuadTree's.

The method getChildren() returns the four childs of the node, stored inside the collection-class called Array ( implementation of Array ). I am sure the return type of getChildren() is indeed Array<QuadTree<?>> (even Eclipse says so inside the tooltip), but I still get an error on this line, telling me:

cannot convert from Array<QuadTree<capture#6-of ?>> to Array<QuadTree<?>>

Here comes the fun part: When I ask Eclipse for suggestions how to solve this, this is one of the suggestions:

Change type of 'children' to 'Array<QuadTree<?>>'

But it already is of this type! It get's better: When I click on this suggestion, Eclipse changes this line to:

Array<?> children = node.getChildren();

Of course, this destroys all the following code.

What the heck is going on here? Could someone enlighten me, please?

Answer 1

The problem is the method doesn't know it's the same QuadTree<?> (the ? could refer to different types in the same call).

The solution is to "type" the method, which locks in QuadTree<?> (and therefore ? ) to be the same type throughout the method.

private <T extends QuadTree<?>> void drawQuadtreeBoxes_helper(T node) {
    if (node == null)
        return;

    Vector3 min = node.bbox.min;
    Vector3 max = node.bbox.max;
    // Draw the boxes (...)

    if (node.hasChildren()) {
        Array<T> children = node.getChildren(); // ERROR HERE
        for (T child : children) {
            drawQuadtreeBoxes_helper(child);
        }
    }
}

? still means "anything", but it now the same "anything".

Answer 2

In addition to Bohemian's answer, I want to point out that you can still have the same signature that you want (nobody needs to know that you are using this "T" type parameter, because it's an implementation detail.

You can do that by making a wrapper method, with the original type signature, that calls the generic method with T. The call works due to capture.

private void drawQuadtreeBoxes_helper(QuadTree<?> node) {
    drawQuadtreeBoxes_helper_private(node);
}

private <T extends QuadTree<?>> void drawQuadtreeBoxes_helper_private(T node) {
    // code here ...
}

Of course, since the method in your example is private, you might not bother to do all this. But if it was a public API, it might be a good idea to do this, to abstract away the unnecessary implementation detail of the T.

Answer 3

If you do not care about type argument inside QuadTree simple remove everywhere from you code:) Just tried following code, compiler considers it as OK:

private void drawQuadtreeBoxes_helper(QuadTree node) {
    if (node == null)
        return;

    Vector3 min = node.bbox.min;
    Vector3 max = node.bbox.max;
    // Draw the boxes (...)

    if (node.hasChildren()) {
        Array<QuadTree> children = node.getChildren();
        for (QuadTree child : children) {
            drawQuadtreeBoxes_helper(child);
        }
    }
}