Is there a way to avoid @SuppressWarnings in this code?

Question

Is there a way to avoid using @SuppressWarnings below and to keep the same functionality without the warning 'Type safety: Unchecked cast from AbstractDO[] to E[]':

public MyClass {
  ...
  private Map<Class<? extends AbstractDO>, AbstractDO[]> map;
  ...
  private void saveConcreteDOs(AbstractDO[] theEntities) {        
    entityMap.put(theEntities[0].getClass(), theEntities);
  }

  @SuppressWarnings("unchecked")
  protected <E extends AbstractDO> E[] getConcreteDOs(Class<E> theType) {
    return (E[]) map.get(theType);
  }
  ...
}

Maybe enhance map declaration?

Answer 1

You have a choice: either suppress the warning for a cast you know will always succeed, or avoid the warning and verify that the cast succeeded with a try/catch block.

There are only those two choices.

maybe there is a way to enhance map declaration?

In your case, I'd say you have a few options.

I think your best bet is to add a throws ClassCastException clause to your getConcreteDOs method and let the caller deal with an invalid cast brought on by an invalid use of the method -- assuming they could get it to compile around your extends AbstractDO clause. This has the unfortunate side effect of forcing the consumer to wrap the call in a try/catch block or declare their own throws clause to force a try/catch block higher up the stack.

You could just swallow the exception with an empty catch block; frankly I'd prefer the @SuppressWarning over that.

Or you could drop the method entirely and only deal in abstract entities, effectively making the consumer of your repository deal with the cast.

Bottom line: you're going to have these issues whenever you try to build generic repositories. You might be better off with a concrete-repository-per-entity-type pattern.

Answer 2

You can avoid the unchecked cast by making your class generic, e.g.

public class MyClass<E extends AbstractDO> {

    private Map<Class<? extends AbstractDO>, E[]> map;

    public void saveConcreteDOs(E[] theEntities) {        
      map.put(theEntities[0].getClass(), theEntities);
    }

    public E[] getConcreteDOs(Class<E> theType) {
      return map.get(theType);
    }
}

Answer 3

First, your code is not type safe. It can throw class cast exception at runtime. You should have

  private void saveConcreteDOs(AbstractDO[] theEntities) {        
    entityMap.put(theEntities.getClass().getComponentType(), theEntities);
  }

You may have only homogeneous arrays at runtime, and element[0] has the same type as the array component type. However, there's no way to know that by examing this class alone.

With this corrected code, a super smart compiler can prove that getConcreteDOs() is type safe. However javac is not that smart. It's required by language spec to throw a warning.

Generally, there is no way to express more sophisticated relations between keys and values in Java. The invariant, that a value is an array whose component type is the key, is only maintained in your head.

Now, look at this non-array version:

private Map<Class<? extends AbstractDO>, AbstractDO> map;

protected <E extends AbstractDO> E getConcreteDOs(Class<E> theType) 
{
  AbstractDO obj = map.get(theType);
  return theType.cast(obj);
}

This has no warning, but it's kind of cheating. Class.cast() hides the warning for us, that's all.

It doesn't help the array version, there is no T[] castArray(Object[]) in Class<T>. You can make one method yourself, effectively hide the warning in it.

Or you can do this, but it's really unnecessarily tacky. Don't be afraid of unchecked cast warning if you know what you are doing and you examined carefully your program to ensure type safety.

protected <E extends AbstractDO> E[] getConcreteDOs(Class<E[]> arrayType) 
{
  AbstractDO[] array = map.get(arrayType.getComponentType());
  return arrayType.cast(array);
}
...
X[] array = getConcreteDOs(X[].class);