重新设计未经检查的强制转换警告

Question

我有一个类将包含几个不同对象的不同解析器实现。尽管我能够在没有任何警告的情况下存储解析器实现，但从映射中获取解析器会警告未经检查的转换异常。下面是一个简化的摘录：

private Map<Class<?>, Parser<?>> parsers = new HashMap<>(); 

public <T> void addParser(Class<T> type, Parser<T> parser) { 
    parsers.put(type, parser); 
} 

private <T> Parser<T> parserFor(Class<T> type) { 
    // Compiler complains about unchecked cast below 
    return (Parser<T>) parsers.get(type); 
} 

是否有另一种方法来实现类似的逻辑，而不会导致未经检查的转换警告？

Answer 1

没有办法创建一个Map<Class<...>, Parser<...>>其中... -s可以是任何东西，但必须匹配一个键和它的值;所以你不可能让编译器为你做检查，其中检索Class<T>保证给你一个Parser<T>。但是，您的代码本身是正确的; 你知道你的演员是正确的，即使编译器没有。

所以，当你知道你的演员是正确的，但Java不知道它，你能做什么？

最好和最安全的方法是制作一段尽可能小的特定代码，负责处理已检查和未检查逻辑之间的转换，并确保未检查的逻辑不会导致任何错误错误。然后，您只需使用适当的@SuppressWarnings注释标记该代码即可。例如，你可以有这样的事情：

public abstract class Parser<T> { 
    private final Class<T> mType; 

    protected Parser(final Class<T> type) { 
     this.mType = type; 
    } 

    public final Class<T> getType() { 
     return mType; 
    } 

    @SuppressWarnings("unchecked") 
    public final <U> Parser<U> castToParserOf(final Class<U> type) { 
     if (type == mType) { 
      return (Parser<U>) this; 
     } else { 
      throw new ClassCastException("... useful message ..."); 
     } 
    } 
} 

这将允许您安全地写在你的榜样：

public <T> void addParser(final Parser<T> parser) { 
    parsers.put(parser.getType(), parser); 
} 

private <T> Parser<T> parserFor(final Class<T> type) { 
    return parsers.get(type).castToParserOf(type); 
} 

Answer 2

由于地图parsers值类型是Parser<?>和你的方法的返回类型为Parser<T>，这显然给parsers.get(type)结果转换为T错误。

之一删除编译错误的方式是投类型Parser<T>：

private <T> Parser<T> parserFor(Class<T> type) { 
    return (Parser<T>)parsers.get(type); 
} 

另外，还可以从你指定的解析器地图为Map<Class<?>, Parser<?>>返回类型更改为Parser<?>。这也将清除编译错误。

private <T> Parser<?> parserFor(Class<T> type) { 
    return parsers.get(type); 
} 

或者你可以添加类型参数到你的包装类。

public class YourClass<T> { 
    private Map<Class<T>, Parser<T>> parsers = new HashMap<>(); 

    public void addParser(Class<T> type, Parser<T> parser) { 
    parsers.put(type, parser); 
    } 

    private Parser<T> parserFor(Class<T> type) { 
    return parsers.get(type); 
    } 
} 

我不确定哪一个可以正确应用，但是，尽量不要使用类型转换。考虑我们为什么使用通用。

Answer 3

考虑使用Google Guava的TypeToInstanceMap<Parser<?>>。这将让你做这样的事情，没有编译器警告或错误责任：

TypeToInstanceMap<Parser<?>> parsers; 

parsers.put(new TypeToken<Parser<String>>(){}, 
      makeStringParser()); 

Parser<Integer> intParser = parsers.get(new TypeToken<Parser<Integer>>(){}); 

这基本上是做非常相似@ruakh's answer引擎盖下的东西的库。

在Java 5发布后不久，开发人员将<T>添加到Class<T>，Neil Gafter，discussed the fundamental issue in his blog。他呼吁Class<T>“类型标记”，并说：

[Y] OU根本无法做出型令牌泛型类型

...换句话说，你可以” t做一个Class<Parser<T>>。

Answer 4

我得到这个以不同的方式工作。我正在尝试用仿制药自己，并会很乐意收到批评:)

我所做的是为Parseable对象添加标记接口，然后将其用作Parser的上界。

public interface IParseable {} 

public class Parser<T extends IParseable> { 
    T paresableObj; 
    // do something with parseableObject here 
} 

而现在解析器工厂不必使用通配符也不使用强制转换。

public class ParserFactory { 

    private Map<Class<?>, Parser<? extends IParseable>> parsers = new HashMap<Class<?>, Parser<? extends IParseable>>(); 

    public <T> void addParser(Class<T> type, Parser<? extends IParseable> parser) { 
     if(parserFor(type) == null){ 
      parsers.put(type, parser); 
     }else{ 
      //throw some excep 
     } 
    } 

    private <T> Parser<? extends IParseable> parserFor(Class<T> type) { 
     return parsers.get(type); 
    } 

}