Java Generics Wildcard Capture Warning

Question

The SCCE below shows 2 classes (B and C) implementing the interface Marker. For each class that implements Marker there is a corresponding class implementing the generic Handler interface (B_Handler, C_Handler). A map is used to associate the Class type of Pair.second to it's associated Handler. The code executes as anticipated; however, I get a compile-time warning:

warning: [unchecked] unchecked cast Handler h1 = (Handler) (dispatch.get(p1.second.getClass())); required: Handler found: Handler where CAP#1 is a fresh type-variable: CAP#1 extends Marker from capture of ? extends Marker

What's the cleanest way to resolve this besides @SuppressWarnings(value = "unchecked")?

package genericpair;

import java.util.HashMap;
import java.util.Map;

import javax.swing.SwingUtilities;

public class GenericPair
{
    public class A
    {
    }

    public interface Marker
    {
    }

    public class B implements Marker
    {
    }

    public class C implements Marker
    {
    }

    public Pair getTarget()
    {
        A a = new A();
        C c = new C();
        return new Pair<>(a, c);
    }

    public interface Handler
    {
        void handle(Pair target);
    }

    public class B_Handler implements Handler
    {
        @Override
        public void handle(Pair target)
        {
            System.out.println("B");
        }
    }

    public class C_Handler implements Handler
    {
        @Override
        public void handle(Pair target)
        {
            System.out.println("C");
        }
    }

    public class Pair
    {
        public final F first;
        public final S second;

        public Pair(F first, S second)
        {
            this.first = first;
            this.second = second;
        }
    }

    private void executeSCCE()
    {
        // register a handler for each Marker type
        Map> dispatch = new HashMap<>();
        dispatch.put(B.class, new B_Handler());
        dispatch.put(C.class, new C_Handler());

        // get a target (e.g., Pair)
        Pair p1 = getTarget();

        // select handler based on the class type of the second parameter
        Handler h1 = (Handler) (dispatch.get(p1.second.getClass()));
        h1.handle(p1);
    }

    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(() -> new GenericPair().executeSCCE());
    }
}

newacct · Accepted Answer

There are several issues.

The first is that your Map is not able to express the type relationship between each key and its value. So if you pass a Class to dispatch.get(), you only get a Handler back, not Handler. In fact, there is no type you can give dispatch to make that work. Instead, you have to make a wrapper class to enforce this relationship via its API:

public class ClassToHandlerMap
{
    private final Map, Handler> map = new HashMap<>();
    public  void put(Class clazz, Handler handler) {
        map.put(clazz, handler);
    }
    @SuppressWarnings("unchecked")
    public  Handler get(Class clazz) {
        return (Handler)map.get(clazz);
    }
}

Note that you do still have to suppress unchecked warnings inside this class, but at least here you know it's provably correct, based on how things are allowed to be put into the map. The unchecked cast is just an implementation detail that the user of this class doesn't need to know about.

The second issue is that getTarget() should probably return Pair instead of Pair. You don't ever have a Handlers of Marker; rather, you have Handlers of particular types of Marker. So it makes sense that you only use Pairs of particular types of Marker too.

public Pair getTarget()
{
    A a = new A();
    C c = new C();
    return new Pair<>(a, c);
}

The last part of your function basically is using p1 to operate on itself, so we need to use a capture helper to "capture" the ? in the type of p1 into a useful type variable for what we need to do.

However, this is more complicated in this case, because you are using .getClass(). foo.getClass() has the type Class where |X| is the erasure of the compile-time type of foo. So no matter if p1 had the type Pair or Pair, p1.second.getClass() would still return the type Class. So capturing on the ? in Pair is not enough; instead, we should capture on the ? in the return of .getClass():

@SuppressWarnings("unchecked")
private static  void captureHelper(Class clazz,
        Pair p, ClassToHandlerMap dispatch) {
    Pair p1 = (Pair)p;

    Handler h1 = dispatch.get(clazz);
    h1.handle(p1);
}

Unfortunately, we will have to do an unchecked cast here also. Due to the peculiar return type of .getClass() we are unable to connect the types of the return of .getClass() and the expression it is called on. And we can't use runtime casting like .cast() to cast between parameterized types (we could use .cast() to get rid of unchecked casts if we were taking an instance of the given class as an argument, but not here). There may be some edge cases in which this is incorrect, but as long as you always use Pair with the second type argument being a final implementing class, it should be correct.

And finally the primary method looks like this:

private void executeSCCE()
{
    // register a handler for each Marker type
    ClassToHandlerMap dispatch = new ClassToHandlerMap();
    dispatch.put(B.class, new B_Handler());
    dispatch.put(C.class, new C_Handler());

    // get a target (e.g., Pair)
    Pair p1 = getTarget();

    // select handler based on the class type of the second parameter
    captureHelper(p1.second.getClass(), p1, dispatch);
}

Java Generics Wildcard Capture Warning

Answers (2)

Related Questions