Java generic upper bounded wildcard error

Question

I have the following entities in my domain model:

class Point {
    public String details;

    public Point() {
        details = "empty";
    }

    public Point(String details) {
        this.details = details;
    }
}

class BasicPoint<X, Y> extends Point {
    public X x;
    public Y y;

    public BasicPoint() {}

    public BasicPoint(X x, Y y) {
        this.x = x;
        this.y = y;
    }
}

class Collector<T> {
    T elem;

    public void collect(T elem) {
        this.elem = elem;
    }
}

I want to apply operations on data and return that data as Point or BasicPoint, as declared above, but the compiler is complaining with the following error although OUT extends Point:

class Operator<OUT extends Point> {
    public Collector<OUT> operate(Collector<OUT> collector) {

        // compile error, collect(OUT) cannot be applied to BasicPoint<Integer, Integer>
        collector.collect(new BasicPoint<Integer, Integer>(1,2));

        return collector;
    }
}

Main method should look like:

Collector<BasicPoint<Integer, Integer>> c = new Collector<>();
c = new Operator<BasicPoint<Integer, Integer>>().operate(c);
System.out.println(c.elem.getClass() == new BasicPoint<Integer, Integer>().getClass());

the problem is that the code does not compile, it shows an error on the Operator class defined in the question — zequihg50, May 13 '16 at 09:46
The error is described in the question: // compile error, collect(OUT) cannot be applied to BasicPoint — zequihg50, May 13 '16 at 09:49

score 2 · Accepted Answer · answered May 13 '16 at 09:55

Your Operator is generic it cannot apply collect on a BasicPoint, only OUT. You can make your Collector abstract:

abstract class Operator<OUT extends Point> {
    abstract Collector <OUT> operate(Collector<OUT> collector);
}

And a BasicPointOperator will then contain the actual implementation which you want:

class BasicPointOperator extends Operator<BasicPoint<Integer, Integer>> {

    @Override
    Collector<BasicPoint<Integer, Integer>> operate(Collector<BasicPoint<Integer, Integer>> collector) {
        collector.collect(new BasicPoint<Integer, Integer>(1,2));
        return collector;
    }
}

or PointOperator, which is a bit more generic

class PointOperator extends Operator<Point> {

    @Override
    Collector<Point> operate(Collector<Point> collector) {
        collector.collect(new BasicPoint<Integer, Integer>(1,2));
        return collector;
    }
}

Afaik it _could_ work the way he programmed it in the first place, do you know _why_ it dosent work? I guess the Compiler just ignore the type of `OUT` inside of `Operator`. — hinneLinks, May 13 '16 at 10:03
It does not work because `BasicPoint` is not of type `OUT`. They just have a common ancestor `Point`. — Federico Nafria, May 13 '16 at 10:13

score 1 · Answer 2 · edited May 23 '17 at 12:16

1

The problem is that you can't put things in unless the type parameter is contravariant. Something like that

public Collector<?>  operate(Collector<? super Point> collector) {
    collector.collect(new BasicPoint<Integer, Integer>(1,2));
    collector.collect(new Point());

    return collector;
 }

edited May 23 '17 at 12:16

Community

1
1

answered May 13 '16 at 10:18

Sleiman Jneidi

22,907
14
56
77

Java generic upper bounded wildcard error

2 Answers2