AP Computer Science a Quiz: Calling Class Methods

What this quiz covers

This quiz focuses on Calling Class Methods, giving you a quick way to practice the rules, question types, and explanations that matter most for AP Computer Science a.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

Question 1

1. It returns 3.0. (correct answer)
2. It returns 6.0.
3. It returns 9.0.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a StudentRecord has 9.0 total points after addGrade(9.0), then calculateGpa(3) divides total points by the parameter value. Choice A is correct as it accurately reflects the calculation: 9.0 / 3 = 3.0. Choice C is incorrect because it returns the total points instead of performing the division, misunderstanding the method's purpose. To help students: Distinguish between methods that return stored values versus those that perform calculations. Practice with methods that take parameters to understand how arguments affect return values.

Question 2

1. It returns -1.
2. It returns 0. (correct answer)
3. It returns 1.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a Library with 1 copy calls issueBook() twice - the first succeeds (reducing to 0), but the second fails because copies must be greater than 0. Choice B is correct as it reflects that only the first issue succeeds: 1 - 1 = 0. Choice A is incorrect because it assumes both issues succeed, resulting in negative copies, which the method prevents. To help students: Trace through multiple method calls with conditional logic step by step. Emphasize understanding preconditions that must be met for methods to execute successfully.

Question 3

1. It returns 1.
2. It returns 2.
3. It returns 3. (correct answer)
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a Library object starts with 0 copies, then addBooks(2) increases it to 2, and returnBook() adds 1 more for a total of 3. Choice C is correct as it accurately reflects both method calls: 0 + 2 + 1 = 3 copies. Choice B is incorrect because it only accounts for the addBooks() call, overlooking the returnBook() effect. To help students: Create sequence diagrams showing multiple method calls and their cumulative effects. Use print statements after each method call during practice to verify state changes.

Question 4

1. It returns 0.5.
2. It returns 9.5.
3. It returns 10.5. (correct answer)
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a BankAccount starts with balance 10.0, then deposit(0.5) adds 0.5 to the balance. Choice C is correct as it accurately reflects the method's output: 10.0 + 0.5 = 10.5. Choice B is incorrect because it subtracts instead of adds, misunderstanding the deposit method's behavior. To help students: Use clear method names that indicate their action (deposit adds, withdraw subtracts). Practice with decimal values to ensure students understand floating-point arithmetic in method calls.

Question 5

1. It returns 60.0.
2. It returns 85.0. (correct answer)
3. It returns 165.0.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a BankAccount object starts with balance 100.0, then deposit(25.0) adds 25 to make 125.0, and withdraw(40.0) subtracts 40 to make 85.0. Choice B is correct as it accurately reflects the method's output after both operations: 100 + 25 - 40 = 85. Choice C is incorrect because it adds both values instead of subtracting the withdrawal, a common error when students misunderstand method functionality. To help students: Use trace tables to track object state changes step-by-step through method calls. Emphasize the importance of understanding whether methods add, subtract, or otherwise modify instance variables.

Question 6

1. It returns -20.0.
2. It returns 0.0.
3. It returns 30.0. (correct answer)
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a BankAccount with balance 30.0 attempts to withdraw(50.0), but the withdraw method only processes when the amount is less than or equal to the current balance. Choice C is correct as the withdrawal fails (50 > 30), so the balance remains 30.0. Choice A is incorrect because it assumes the withdrawal always occurs, resulting in a negative balance, which the method prevents. To help students: Emphasize reading method specifications carefully for conditional behavior. Practice with methods that have validation logic to understand when operations succeed or fail.

Question 7

1. It returns 2.
2. It returns 3. (correct answer)
3. It returns 5.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a CarRental object starts with 5 available cars, then rentCar(2) is called to reduce availability by 2. Choice B is correct as it accurately reflects the method's output: 5 - 2 = 3 cars remaining available. Choice C is incorrect because it returns the original value, indicating the student didn't account for the state change from rentCar(). To help students: Use debugging exercises where students step through code line by line. Emphasize the difference between getter methods (which don't change state) and mutator methods (which do change state).

Question 8

1. It returns 1. (correct answer)
2. It returns 2.
3. It returns 3.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a Library object starts with 2 copies of 'Dune', then issueBook() is called once, which decreases the count by 1. Choice A is correct as it accurately reflects the method's output: 2 - 1 = 1 copy remaining. Choice B is incorrect because it represents the original count, suggesting the student overlooked that issueBook() modifies the state. To help students: Create visual diagrams showing object state before and after each method call. Practice with concrete examples where students predict outcomes before running code to reinforce understanding of state changes.

Question 9

1. It returns 3.5.
2. It returns 7.0. (correct answer)
3. It returns 12.0.
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a StudentRecord object starts with 0 total points, then addGrade(3.0) and addGrade(4.0) are called sequentially, accumulating points. Choice B is correct as it accurately reflects the method's output: 0 + 3.0 + 4.0 = 7.0 total points. Choice A is incorrect because it averages the grades instead of summing them, a misconception about what getTotalPoints() returns. To help students: Distinguish between methods that accumulate values versus those that calculate averages. Use method documentation and naming conventions to clarify method behavior before implementation.

Question 10

1. It returns -1.
2. It returns 0.
3. It returns 1. (correct answer)
4. It causes a syntax error.

Explanation: This question tests understanding of calling class methods in Java, central to APCSA. Method calls allow interaction with objects by executing predefined actions or calculations, often influencing object state or returning data. In this scenario, a CarRental with 1 available car attempts to rentCar(2), but the method only processes when enough cars are available. Choice C is correct as the rental fails (can't rent 2 when only 1 available), so availability remains 1. Choice B is incorrect because it assumes the partial rental occurs, which typical implementations prevent. To help students: Discuss edge cases and validation in method implementations. Practice tracing through conditional logic within methods to predict when operations will or won't execute.

Question 11

public static int digitSum(int n) {
    int sum = 0;
    n = Math.abs(n);
    while (n > 0) {
        sum += n % 10;
        n /= 10;
    }
    return sum;
}

public static boolean isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= Math.sqrt(n); i++) {
        if (n % i == 0) return false;
    }
    return true;
}

1. evenCheck is true and primeCheck is true, because the digit sum is 12, which is both even and prime
2. evenCheck is true and primeCheck is false, because the digit sum is 12, which is even but not prime (correct answer)
3. evenCheck is false and primeCheck is true, because the digit sum is 11, which is odd but prime
4. evenCheck is false and primeCheck is false, because the digit sum is 13, which is neither even nor prime

Explanation: First, digitSum(-147) takes the absolute value (147) and sums the digits: 1 + 4 + 7 = 12. Then, isEven(12) returns true because 12 % 2 == 0. Finally, isPrime(12) returns false because 12 has divisors other than 1 and itself (e.g., 12 % 2 == 0, so 2 is a divisor). Choice A incorrectly claims 12 is prime. Choice C incorrectly calculates the digit sum as 11. Choice D incorrectly calculates the digit sum as 13.

Question 12

public static int countVowels(String str) {
    int count = 0;
    String vowels = "aeiouAEIOU";
    for (int i = 0; i < str.length(); i++) {
        if (vowels.indexOf(str.charAt(i)) != -1) {
            count++;
        }
    }
    return count;
}

1. 3, because the original string has 3 vowels and case reversal doesn't change vowel count
2. 4, because the modified string "hELLO wORLD!" contains vowels h, E, O, and O
3. 5, because the modified string contains all uppercase and lowercase vowels from the original
4. 3, because the modified string "hELLO wORLD!" contains vowels E, O, and O (correct answer)

Explanation: When you encounter string manipulation problems on the AP Computer Science A exam, you need to carefully trace through each method's logic step by step, paying attention to how characters are transformed. Let's trace through this code systematically. The reverseCase method takes "Hello World!" and flips the case of each letter while leaving non-letters unchanged. Going character by character: 'H' becomes 'h', 'e' becomes 'E', 'l' becomes 'L', and so on. The complete transformation gives us "hELLO wORLD!" Next, countVowels checks each character in "hELLO wORLD!" against the vowels string "aeiouAEIOU". The method uses indexOf(), which returns -1 if a character isn't found in the vowels string. Scanning through "hELLO wORLD!", we find: 'h' (not a vowel), 'E' (vowel #1), 'L' (not a vowel), 'L' (not a vowel), 'O' (vowel #2), space (not a vowel), 'w' (not a vowel), 'O' (vowel #3), 'R' (not a vowel), 'L' (not a vowel), 'D' (not a vowel), '!' (not a vowel). Total: 3 vowels. Choice A correctly identifies that case reversal doesn't change vowel count but miscounts the original vowels. Choice B incorrectly identifies 'h' as a vowel—it's not in the vowels string. Choice C suggests all vowels are preserved somehow, which doesn't match our count. Remember to always trace string methods character by character rather than making assumptions. Method calls that transform strings require careful step-by-step analysis to avoid counting errors.

Question 13

public static double divide(double a, double b) {
    return a / b;
}

public static double average(double a, double b) {
    return divide(Calculator.multiply(a, 2.0) + Calculator.multiply(b, 2.0), 4.0);
}

1. 8.0, because the method calculates (6.0 * 2.0 + 10.0 * 2.0) / 4.0 which simplifies to the average (correct answer)
2. 8.0, because the method correctly calculates the arithmetic mean of 6.0 and 10.0
3. 16.0, because the method calculates (6.0 * 2.0 + 10.0 * 2.0) / 2.0 instead of dividing by 4.0
4. 4.0, because the method incorrectly doubles both numbers before averaging them

Explanation: When you encounter method tracing questions, you need to carefully follow the execution path step by step, paying attention to how methods call other methods within the same class. Let's trace through Calculator.average(6.0, 10.0). The average method calls Calculator.multiply(a, 2.0) + Calculator.multiply(b, 2.0) in the numerator, then passes that sum to the divide method with 4.0 as the denominator. First, Calculator.multiply(6.0, 2.0) returns $6.0 \times 2.0 = 12.0$. Then Calculator.multiply(10.0, 2.0) returns $10.0 \times 2.0 = 20.0$. The sum is $12.0 + 20.0 = 32.0$. Finally, Calculator.divide(32.0, 4.0) returns $32.0 ÷ 4.0 = 8.0$. Choice A correctly identifies this calculation and notes that it does simplify to the average of 6.0 and 10.0. Choice B is wrong because while 8.0 is indeed the arithmetic mean of 6.0 and 10.0, the method doesn't calculate it in the standard way—it uses an unnecessarily complex approach that happens to work. Choice C incorrectly states the method divides by 2.0 instead of 4.0, but if you look at the code, it clearly passes 4.0 to the divide method. Choice D claims the result is 4.0, but our calculation shows it's 8.0. Study tip: When tracing method calls, write out each step with actual values substituted. Don't assume a method works correctly based on its name—follow the actual code logic to see what it really does.

Question 14

1. The program prints 0 because the length of a null string is defined as 0 in Java
2. The program prints -1 because null strings return -1 when the length method is called
3. A NullPointerException is thrown because you cannot call instance methods on a null reference (correct answer)
4. A compilation error occurs because the length method cannot be called on a potentially null string

Explanation: When str is null and you attempt to call str.length(), a NullPointerException is thrown at runtime because you cannot invoke instance methods on a null reference. Choice A is incorrect because null strings don't have a defined length of 0. Choice B is incorrect because the method call fails before any value can be returned. Choice D is incorrect because this is a runtime error, not a compilation error - the compiler doesn't prevent calling methods on potentially null references.

Question 15

1. 9.0, because Math.abs(-3.7) returns 3.7 and Math.floor(2.9) returns 2.0, so 3.7² equals 13.69
2. 13.69, because Math.abs(-3.7) returns 3.7 and Math.floor(2.9) returns 2.0, giving 3.7 raised to the 2nd power (correct answer)
3. 10.24, because Math.abs(-3.7) returns 3.2 and Math.floor(2.9) returns 3.0, so 3.2³ equals 32.768
4. 16.0, because Math.abs(-3.7) returns 4.0 and Math.floor(2.9) returns 2.0, giving 4.0 raised to the 2nd power

Explanation: Math.abs(-3.7) returns 3.7 (the absolute value). Math.floor(2.9) returns 2.0 (the largest integer less than or equal to 2.9). Therefore, Math.pow(3.7, 2.0) calculates 3.7², which equals 13.69. Choice A incorrectly states the final calculation result. Choice C has wrong values for both Math.abs(-3.7) and Math.floor(2.9). Choice D incorrectly claims Math.abs(-3.7) returns 4.0.

Question 16

1. Static methods can only be called using the class name, never through an instance reference, and this restriction is enforced at compile time
2. Static methods can be called using either the class name or an instance reference, but using an instance reference generates a compiler warning
3. Static methods can be called using either the class name or an instance reference, with no difference in behavior or compiler messages (correct answer)
4. Static methods can be called through an instance reference only when the instance is not null, otherwise a NullPointerException occurs

Explanation: Static methods can indeed be called using either the class name (preferred style) or through an instance reference. When called through an instance, the instance is not actually used - the method belongs to the class, not the instance. Java allows both syntaxes without generating compiler warnings, though IDEs may suggest using the class name for clarity. Choice A is incorrect because instance references can be used. Choice B is incorrect because no compiler warning is generated. Choice D is incorrect because even if the instance reference is null, the static method will still execute normally since the instance is not actually used.

Question 17

1. 9, because the outer Math.max compares 8 and 9, returning the larger value (correct answer)
2. 8, because the outer Math.max compares 8 and 9, returning the larger value
3. 12, because the inner Math.max(5, 9) returns 9, then Math.min(12, 9) returns 9, and Math.max(8, 9) returns 12
4. 15, because Math.min(15, 8) returns 15, which is larger than any other intermediate result

Explanation: When you encounter nested function calls like this, the key is to evaluate from the inside out, just like you would with nested parentheses in algebra. Start with the innermost function calls and work your way outward. Let's trace through this step by step: First, evaluate the innermost functions:

• Math.min(15, 8) returns 8 (the smaller of 15 and 8)
• Math.max(5, 9) returns 9 (the larger of 5 and 9)