Java泛型-在调用instanceof之后，有什么方法可以避免强制转换（和未经检查的警告）？

Question

Android代码-SharedPreferences类导出用于持久/检索不同首选项的不同方法：

@SuppressWarnings("unchecked")
public static <T> T retrieve(Context ctx, String key, T defaultValue) {
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ctx);
    if (defaultValue instanceof Boolean) return (T) (Boolean) prefs
            .getBoolean(key, (Boolean) defaultValue);
    else if (defaultValue instanceof Float) return (T) (Float) prefs
            .getFloat(key, (Float) defaultValue);
    // etc - another 4 cases
}

这行得通，我可以调用boolean stored = retrieve(ctx, "BOOLEAN_KEY", true) -但是我的问题是：由于我已经使用过instanceof且T已简化为特定的类，因此有一种避免单boolean stored = retrieve(ctx, "BOOLEAN_KEY", true)的方法演员和warning : unchecked ？

编辑 ：如果我要通过该类中，我不妨调用getBoolean()或getFloat()等。我想要的是简化方法的内部结构，摆脱警告，但仍然能够调用retrieve(ctx, "KEY", 1 or "string" or true)然后获取我想要的内容

Answer 1

简短的回答：不，您不能摆脱警告。 他们在那里是有原因的。

更长的答案：您可能已经知道，Java中的泛型只是语法糖加上编译时检查。 几乎没有任何东西可以生存到运行时（称为“擦除”的过程）。 这意味着您方法中的(T)强制转换实际上是无操作的。 它将转换为最具体的类型，在这种情况下为Object 。 所以这：

(T) (Boolean) prefs.whatever()

真的变成这样：

(Object) (Boolean) prefs.whatever()

当然与以下内容相同：

(Boolean) prefs.whatever()

这可能会使您陷入危险境地，而警告正试图告诉您。 基本上，您将丢失类型安全性，并且最终可能使您远离错误的实际位置（因此很难进行跟踪）。 想象以下情况：

// wherever you see "T" here, think "Object" due to erasure
public <T> void prefsToMap(String key, T defaultValue, Map<String, T> map) {
    T val = retrieve(this.context, key, defaultValue);
    map.put(key, val);
}

Map<String,Integer> map = new HashMap<>();
prefsToMap("foo", 123, map);
// ... later
Integer val = map.get("foo");

到目前为止，一切都很好，并且在您的情况下也可以使用，因为如果“ foo”位于首选项中，则您将调用getInt来获取它。 但是，请想象一下，如果您的retrieve函数中有一个错误，例如if( defaultValue instanceof Integer)意外返回了getDouble()而不是getInt() （带有强制转换以及所有这些）。 编译器不会捕获它，因为您对T的强制转换实际上只是对Object强制转换！ 直到Integer val = map.get("foo");您才能找到Integer val = map.get("foo"); ，它变成：

Integer val = (Integer) map.get("foo"); // cast automatically inserted by the compiler

此强制转换可能与错误真正发生的地方（ getObject调用）相距很远，这使得很难进行跟踪。 Javac试图保护您免受此侵害。

这是所有内容放在一起的示例。 在此示例中，我将使用Number代替prefs对象，只是为了使事情保持简单。 您可以复制粘贴此示例，然后按原样尝试。

import java.util.*;

public class Test {
    @SuppressWarnings("unchecked")
    public static <T> T getNumber(Number num, T defaultVal) {
        if (num == null)
            return defaultVal;
        if (defaultVal instanceof Integer)
            return (T) (Integer) num.intValue();
        if (defaultVal instanceof String)
            return (T) num.toString();
        if (defaultVal instanceof Long)
            return (T) (Double) num.doubleValue(); // oops!
        throw new AssertionError(defaultVal.getClass());
    }

    public static void getInt() {
        int val = getNumber(null, 1);
    }

    public static void getLong() {
        long val = getNumber(123, 456L); // This would cause a ClassCastException
    }

    public static <T> void prefsToMap(Number num, String key, T defaultValue, Map<String, T> map) {
        T val = getNumber(num, defaultValue);
        map.put(key, val);
    }

    public static void main(String[] args) {
        Map<String, Long> map = new HashMap<String,Long>();
        Long oneTwoThree = 123L;
        Long fourFixSix = 456L;
        prefsToMap(oneTwoThree, "foo", fourFixSix, map);
        System.out.println(map);
        Long fromMap = map.get("foo"); // Boom! ClassCastException
        System.out.println(fromMap);
    }
}

注意事项：

• 最重要的一点：即使应该使用泛型来提供类型安全性，但我还是得到了ClassCastException。 不仅如此，我在一段代码中也得到了错误，根本没有错误（ main ）。 该错误发生在prefsToMap ，但是main支付了费用。 如果map是一个实例变量，它可能是很难跟踪，其中引入的错误。
• 除了使用数字代替首选项外，我的getNumber与您的retrieve函数几乎相同
• 我故意创建了一个错误：如果defaultVal是Long ，我将得到double（而不是long）（并将其强制转换为T ）。 但是类型系统无法捕获此错误，这正是未经检查的强制转换试图警告我的内容（警告我它不能捕获任何错误，不一定有错误）。
• 如果defaultValue是int或String，则一切都会好起来。 但是，如果它是Long，并且num为null，那么当呼叫站点期望Long时，我将返回Double 。
• 因为我的prefsToMap类仅强制转换为T （如上所述，它是无操作强制转换），所以不会引起任何强制转换异常。 在倒数第二行Long fromMap = map.get("foo")之前，我不会例外。

使用javap -c ，我们可以看到其中一些在字节码中的样子。 首先，让我们看一下getNumber 。 请注意，对T的强制转换不会显示为任何内容：

public static java.lang.Object getNumber(java.lang.Number, java.lang.Object);
  Code:
   0:   aload_0
   1:   ifnonnull   6
   4:   aload_1
   5:   areturn
   6:   aload_1
   7:   instanceof  #2; //class java/lang/Integer
   10:  ifeq    21
   13:  aload_0
   14:  invokevirtual   #3; //Method java/lang/Number.intValue:()I
   17:  invokestatic    #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
   20:  areturn
   21:  aload_1
   22:  instanceof  #5; //class java/lang/String
   25:  ifeq    33
   28:  aload_0
   29:  invokevirtual   #6; //Method java/lang/Object.toString:()Ljava/lang/String;
   32:  areturn
   33:  aload_1
   34:  instanceof  #7; //class java/lang/Long
   37:  ifeq    48
   40:  aload_0
   41:  invokevirtual   #8; //Method java/lang/Number.doubleValue:()D
   44:  invokestatic    #9; //Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
   47:  areturn
   48:  new #10; //class java/lang/AssertionError
   51:  dup
   52:  aload_1
   53:  invokevirtual   #11; //Method java/lang/Object.getClass:()Ljava/lang/Class;
   56:  invokespecial   #12; //Method java/lang/AssertionError."<init>":(Ljava/lang/Object;)V
   59:  athrow

接下来，看看getLong 。 注意，它将getNumber的结果强制转换为Long ：

public static void getLong();
  Code:
   0:   bipush  123
   2:   invokestatic    #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
   5:   ldc2_w  #15; //long 456l
   8:   invokestatic    #17; //Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
   11:  invokestatic    #13; //Method getNumber:(Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
   14:  checkcast   #7; //class java/lang/Long
   17:  invokevirtual   #18; //Method java/lang/Long.longValue:()J
   20:  lstore_0
   21:  return

最后，这是prefsToMap 。 请注意，由于它仅处理通用T类型（也称为对象），因此根本不进行任何转换。

public static void prefsToMap(java.lang.Number, java.lang.String, java.lang.Object, java.util.Map);
  Code:
   0:   aload_0
   1:   aload_2
   2:   invokestatic    #13; //Method getNumber:(Ljava/lang/Number;Ljava/lang/Object;)Ljava/lang/Object;
   5:   astore  4
   7:   aload_3
   8:   aload_1
   9:   aload   4
   11:  invokeinterface #19,  3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
   16:  pop
   17:  return

Answer 2

通常的方法是使用Class.cast（obj），但是您将需要一个T类的实例，通常通过将一个实例传递给该方法来完成，但是您的情况会很好：

return Boolean.class.cast(pregs.getBoolean(key, (Boolean)defaultValue));

编辑：评论后，是的，可能是类型不匹配的问题。

您将需要将类类型作为方法的一部分传递，或者从默认值（如果它不为null）进行推断：

return defaultValue.getClass().cast(pregs.getBoolean(key, (Boolean)defaultValue));

使用工作示例再次进行编辑（这对我没有任何警告）：

public class JunkA {

    private boolean getBoolean(String key, boolean def) {
        return def;
    }

    private float getFloat(String key, float def) {
        return def;
    }

    private String getString(String key, String def) {
        return def;
    }

    private int getInt(String key, int def) {
        return def;
    }

    public <T> T getProperty(final Class<T> clazz, final String key,
            final T defval) {
        if (clazz.isAssignableFrom(Boolean.class)) {
            return clazz.cast(getBoolean(key, (Boolean) defval));
        }
        if (clazz.isAssignableFrom(String.class)) {
            return clazz.cast(getString(key, (String) defval));
        }
        if (clazz.isAssignableFrom(Boolean.class)) {
            return clazz.cast(getFloat(key, (Float) defval));
        }
        if (clazz.isAssignableFrom(Integer.class)) {
            return clazz.cast(getInt(key, (Integer) defval));
        }
        return defval;
    }

}

Answer 3

好吧我的问题 是 是（简单）： 由于我已经使用过instanceof，并且T归结为特定的类，有没有一种方法可以避免单次和两次强制转换以及警告：未选中？

答案是否定的 -我引用此特定答案是因为它表明我并不是唯一一个纳闷的人。 但是您可能希望对这个有趣的问题进行投票，尽管@yshavit的主题答案有些偏离：)