Question

据我所知，使用Integer示例自动装箱用法是：

Integer iOb2 = 88; // auto-boxing
Integer iOb = new Integer(88) // is it auto-boxing ? I think no
                              // if it is auto-boxing what about above line?

以上代码段有效。但是，你能回答第二行是否自动装箱？使用泛型，我无法获得预期的结果。

// A very simple generic class. 
// Here, T is a type parameter that
// will be replaced by a real type
// when an object of type Gen is created.
class Gen<T> {
  T ob; // declare an object of type T

  // Pass the constructor a reference to 
  // an object of type T.
  Gen(T o) {
    ob = o;
  }

  // Return ob, which is of type T.
  T getob() {
    return ob;
  }
}

// Demonstrate the generic class.
class HelloWorld {
  public static void main(String args[]) {
    // Create a Gen reference for Integers. 
    Gen<Integer> iOb; 
    Integer iOb2;
    // Create a Gen<Integer> object and assign its
    // reference to iOb.  Notice the use of autoboxing 
    // to encapsulate the value 88 within an Integer object.
    //iOb = 88; //error
    iOb2 = 88;

    // Get the value in iOb. Notice that
    // no cast is needed.  The type is already known.
    //int v = iOb.getob();
    System.out.println("value: " + iOb2);

    System.out.println();

    // Create a Gen object for Strings.
    Gen<String> strOb = new Gen<String>("Generics Test");

    // Get the value of strOb. Again, notice
    // that no cast is needed.
    String str = strOb.getob();
    System.out.println("value: " + str);
  }
}

对于这个通用代码，为什么不是引用类型包装类型Gen<Integer>的整数值？什么时候应该呢。不应该吗？

Answer 1

Integer iOb2 = 88由编译器实现为Integer iOb2 = Integer.valueOf(88)。那就是自动拳击。

Integer iOb = new Integer(88)只是您构建一个Integer对象。不是自动拳击。

自动装箱仅用于自动将原始类型转换为等效的Object版本，例如int到Integer。所有自动装箱操作都是使用valueOf()方法完成的，该方法已在Java 5中添加用于此特定目的（Boolean的例外，该方法已存在）。

因此，iOb = 88无效，因为88是int且与Gen<Integer>的作业不兼容。

如果您编写了iOb = new Gen<Integer>(88)，那么在创建对象之前就会导致自动装箱，因为构造函数需要Integer，但您需要提供int。< / p>

<强> PROOF

为了证明自动装箱使用valueOf()，我创建了以下代码：

Boolean   a = true;
Character b = '1';
Byte      c = 1;
Short     d = 1;
Integer   e = 1;
Long      f = 1L;
Float     g = 1f;
Double    h = 1d;

使用生成的javap -c命令进行反汇编（为清晰起见，添加了空白行）：

 0: iconst_1
 1: invokestatic  #19                 // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
 4: astore_1

 5: bipush        49
 7: invokestatic  #25                 // Method java/lang/Character.valueOf:(C)Ljava/lang/Character;
10: astore_2

11: iconst_1
12: invokestatic  #30                 // Method java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
15: astore_3

16: iconst_1
17: invokestatic  #35                 // Method java/lang/Short.valueOf:(S)Ljava/lang/Short;
20: astore        4

22: iconst_1
23: invokestatic  #40                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
26: astore        5

28: lconst_1
29: invokestatic  #45                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
32: astore        6

34: fconst_1
35: invokestatic  #50                 // Method java/lang/Float.valueOf:(F)Ljava/lang/Float;
38: astore        7

40: dconst_1
41: invokestatic  #55                 // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
44: astore        8

Answer 2

new Integer(88)不是自动装箱 - 最接近的可用术语是＆＃34;拳击＆＃34;，但这实际上只是构造。

在您的第二个代码示例中，您似乎正在尝试将int自动装箱到您的Gen对象中 - 这不是自动装箱的工作方式。

自动装箱仅适用于语言中定义的特定类型 - 例如int只能自动装箱到Integer，而不是您定义的类型（例如{ {1}}）

Answer 3

Integer iOb = new Integer(88);不是自动装箱，Integer在其构造函数重载之一中使用int参数（请参阅API）。

iOb2 = 88作业使用自动装箱，因为它将int字面值分配给Integer引用。

混淆autoboxing使用与泛型

3 个答案: