PrepGo

AP Computer Science A Practice Quiz: Wrapper Classes

Written by AP Content Team, Verified for 2026 AP Exams, Last updated: May 2026

Test your understanding with short quizzes. This quiz has 10 questions to check your progress.

Question 1 of 10

Which of the following best describes autoboxing in Java?

All Questions (10)

Which of the following best describes autoboxing in Java?

A) The automatic conversion of a wrapper class object to its corresponding primitive type.

B) The automatic conversion of a primitive type to its corresponding object wrapper class.

C) The principle that Integer and Double objects cannot be changed after they are created.

D) The process of including the Integer class within the java.lang package.

Correct Answer: B

Autoboxing is the automatic conversion that the Java compiler makes between primitive types and their corresponding object wrapper classes, for example, from an int to an Integer.

Consider the following line of code: `Integer myNum = 100;` `int primitiveNum = myNum;` The conversion happening in the second line is an example of what process?

A) Autoboxing

B) Unboxing

C) Immutability

D) Instantiation

Correct Answer: B

Unboxing is the automatic conversion from a wrapper class to its primitive type. In this case, the `Integer` object `myNum` is converted to the `int` primitive `primitiveNum`.

What is the output of the following code segment? ```java Integer val1 = 20; int val2 = 10; Double result = val1 / 2.0 + val2; System.out.println(result); ```

A) 20

B) 20.0

C) 15.0

D) A compile-time error occurs.

Correct Answer: B

The `Integer` `val1` is unboxed to the primitive `int` 20. The expression becomes `20 / 2.0 + 10`. Division by a double `2.0` results in a double `10.0`. Then, `10.0 + 10` results in `20.0`. This `double` primitive is then autoboxed into the `Double` object `result`.

Given the code snippet: `Integer count = 5;` `count = count + 5;` Based on the properties of the Integer class, which statement is true about the second line of code?

A) The original Integer object holding the value 5 is modified to hold the value 10.

B) The code will cause a runtime error because arithmetic operations are not allowed on objects.

C) A new Integer object with the value 10 is created, and the reference `count` is updated to point to this new object.

D) The code will not compile because Integer objects are immutable.

Correct Answer: C

Integer objects are immutable. When `count + 5` is executed, `count` is unboxed to 5, the addition is performed resulting in 10, and then a new Integer object is created to hold the value 10 via autoboxing. The reference `count` is then assigned to this new object.

Which of the following statements about the `Integer` and `Double` classes is explicitly mentioned in the provided content?

A) They have a method to compare two objects.

B) They are part of the java.lang package.

C) They consume more memory than their primitive counterparts.

D) They can be used in ArrayLists, while primitives cannot.

Correct Answer: B

The provided content explicitly states that 'The Integer class and Double class are part of the java.lang package.'

Which line of code demonstrates autoboxing?

A) int x = 10;

B) Integer y = 20;

C) int z = y;

D) Double d = new Double(30.0);

Correct Answer: B

Autoboxing is the automatic conversion of a primitive type to its wrapper class. In the line `Integer y = 20;`, the primitive `int` literal `20` is automatically converted into an `Integer` object.

Consider the following method: ```java public void updateValue(Double val) { val = val / 2.0; } ``` And the following code that calls it: ```java Double myDouble = 50.0; updateValue(myDouble); System.out.println(myDouble); ``` What is the output?

A) 25.0

B) 50.0

C) 25

D) A runtime error occurs.

Correct Answer: B

Double objects are immutable. Inside the `updateValue` method, `val / 2.0` creates a new Double object with the value 25.0. The local reference `val` is updated to point to this new object. However, the original reference `myDouble` in the calling scope is unchanged and still points to the original object with the value 50.0.

What is a key characteristic of both `Integer` and `Double` objects as described in the content?

A) They are mutable.

B) They are immutable.

C) They require explicit casting for arithmetic.

D) They are located in the java.util package.

Correct Answer: B

The provided content explicitly states that 'An Integer object is immutable. A Double object is immutable.' This means their state cannot be changed after creation.

What is the result of the following code snippet? ```java Integer a = 15; Double b = 2.5; System.out.println(a * b); ```

A) 37.5

B) 37

C) 38

D) A compile-time error because you cannot multiply an Integer by a Double.

Correct Answer: A

Due to unboxing, the `Integer` `a` is converted to `int` 15, and the `Double` `b` is converted to `double` 2.5. The expression becomes `15 * 2.5`. Because one of the operands is a double, the result is a double, `37.5`.

Which of the following is a direct consequence of the immutability of wrapper class objects like `Integer`?

A) They can be used in arithmetic expressions without explicit conversion.

B) They are stored in a special memory area called the constant pool.

C) Operations that seem to change the object, like `i++`, result in the creation of a new object.

D) They are automatically converted from their primitive types by the compiler.

Correct Answer: C

Because an `Integer` object's value cannot be changed, any operation that appears to modify it must create a new object with the new value. The original object remains unchanged. Unboxing and autoboxing are the mechanisms that make this seamless, but the creation of a new object is the consequence of immutability.