Generics, Inheritance and Type Erasure problem

Question

I can't wrap my head around, why the following code snippet including generics and wildcards is not valid.

package test;

public class App {

    private interface Condition {
        String get();
    }

    private interface Processor<T extends Condition> {
        boolean process(final T condition);
    }

    private static class HolderClass<T extends Condition> {

        private final Processor<T> processor;
        private final T condition;

        public HolderClass(final Processor<T> processor, final T condition) {
            this.processor = processor;
            this.condition = condition;
        }

        public Processor<T> getProcessor() {
            return processor;
        }

        public T getCondition() {
            return condition;
        }

    }

    private static class FirstCondition implements Condition {
        @Override
        public String get() {
            return "concrete";
        }
    }

    private static class FirstProcessor implements Processor<FirstCondition> {
        @Override
        public boolean process(FirstCondition condition) {
            System.out.println(condition.get());
            return false;
        }
    }

    public static void main(String[] args) {
        final HolderClass<? extends Condition> holder = new HolderClass<>(new FirstProcessor(), new FirstCondition());
        holder.getProcessor().process(holder.getCondition()); // error here
    }

}

This fails with Compilation failure .../test/App.java:[58,46] incompatible types: test.App.Condition cannot be converted to capture#1 of ? extends test.App.Condition

I already have read a lot about type erasure, but can anyone try to explain what's the actual problem and maybe provide an counter example why this is not allowed?

Thanks.

Can you point out line 58 in your code? Maybe we could figure it out anyway, but it would be much easier for us if you point out the line in the error message. — Roger Gustavsson, Aug 02 '19 at 14:32
You've declared `holder` to have generic type `?` (unknown), so the compiler can't establish that the `?` linked to `holder.getCondition()` is the same as the `T` expected by `process`. If you rewrite it to remove the unknown, you can probably get it to work. — khelwood, Aug 02 '19 at 14:32
`? extends Condition` means *an unknown but specific type which is `Condition` or a subclass*. — MC Emperor, Aug 02 '19 at 14:46
Related: [What is PECS](https://stackoverflow.com/q/2723397) — Jorn Vernee, Aug 02 '19 at 14:48

score 1 · Accepted Answer · answered Aug 02 '19 at 14:50

? extends used to declare a generic class is classic. You use that to set the boundaries of your generic class.
But as you instantiate a generic type, you generally specify the type that you need to manipulate and you don't use still declare that with an upper bounded wildcard because this sets some rules that give you some possibilities (assignation it from subtypes variable) but also some constraints.

A example that should help you to understand :

List<? extends Number> numbers = null;
numbers.add(1); // Doesn't compile for same reason

If you want to add numbers you declare :

List<Number> numbers = null;
numbers.add(1);

In a general way, a variable Foo<? extends Bar> cannot be invoked with a generic parameter for type safety reasons :

List<? extends Number> numbers = null;
List<? extends Float> floats = null;
numbers = floats;  // valid
numbers.add(Long.valueOf(1)); // doesn't compile since no type safe

So specify the type that you manipulate (FirstCondition):

final HolderClass<FirstCondition> holder = new HolderClass<>(new FirstProcessor(), new FirstCondition());
holder.getProcessor().process(holder.getCondition());

Generics, Inheritance and Type Erasure problem

1 Answers1