AP Computer Science a Quiz: Abstraction And Program Design

What this quiz covers

This quiz focuses on Abstraction And Program Design, 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. manufacturer and screenResolution as class variables; serialNumber and batteryPercentage as instance variables. (correct answer)
2. All four attributes (manufacturer, screenResolution, serialNumber, batteryPercentage) should be designed as instance variables.
3. All four attributes (manufacturer, screenResolution, serialNumber, batteryPercentage) should be designed as class variables.
4. serialNumber as a class variable; manufacturer, screenResolution, and batteryPercentage as instance variables.

Explanation: Class variables (static) are used for data that is shared by all instances of a class. manufacturer and screenResolution fit this description. Instance variables are used for data that is unique to each instance. serialNumber and batteryPercentage are specific to each individual laptop object, making them ideal instance variables.

Question 2

1. Data encapsulation, which hides the internal state of an object from the outside world.
2. Method overloading, which allows multiple methods to have the same name with different parameter lists.
3. Method decomposition, which breaks down a complex behavior into smaller, manageable procedures. (correct answer)
4. Object instantiation, which is the process of creating a new instance of a class.

Explanation: Method decomposition is the process of breaking a large, complex method into several smaller, simpler helper methods. This improves code readability, makes it easier to test individual pieces of logic, and promotes code reuse. The scenario described is a classic example of this design principle.

Question 3

1. Create multiple overloaded versions of the method, one for each common width and height combination.
2. Change the method's name to calculateAreaOf10x5Rectangle to make its limited purpose more explicit.
3. Add width and height parameters to the method so it can calculate the area for any rectangle, not just one specific size. (correct answer)
4. Keep the method as is, but add extensive comments explaining that it only works for a 10x5 rectangle.

Explanation: Generalization is achieved by replacing specific, hard-coded values with parameters. By adding width and height as parameters, the method is no longer tied to a single case and becomes a reusable tool for calculating the area of any rectangle, which is a much more abstract and useful design.

Question 4

1. Because of inheritance, which ensures that changes to a superclass method are automatically applied to all subclasses.
2. Because of procedural abstraction, which separates the method's interface (its signature) from its implementation (its internal logic). (correct answer)
3. Because of polymorphism, which allows an object to take on many forms and behave differently depending on its type.
4. Because of data encapsulation, which bundles the sort method together with the data it operates on.

Explanation: Procedural abstraction means that the caller of a method only needs to know what the method does (as defined by its signature and documentation), not how it does it. As long as the signature (public static int[] sort(int[] data)) and the overall behavior (sorting an array) remain the same, the internal implementation can be changed without affecting the code that uses it.

Question 5

1. An instance variable for the unique ID number and a class variable to store the total count of students. (correct answer)
2. A class variable for the unique ID number and an instance variable to store the total count of students.
3. Both the unique ID number and the total count of students should be stored as instance variables.
4. Both the unique ID number and the total count of students should be stored as class variables.

Explanation: An instance variable is appropriate for the ID number because each Student object needs its own unique value. A class variable (static) is appropriate for the total count because this value is shared across all Student objects and belongs to the class as a whole, not to any single instance.

Question 6

1. An attribute is a synonym for a method's behavior, while an instance variable is a specific type of data storage used only within constructors.
2. An instance variable is a specific type of attribute; its value is unique to each object and helps define that object's state. (correct answer)
3. An attribute is always a class variable shared by all objects, while an instance variable is unique to a single object.
4. An attribute and an instance variable are completely unrelated concepts; attributes relate to design, and instance variables relate to syntax.

Explanation: An attribute is a general term for a property or characteristic of a class in the design phase. An instance variable is the concrete implementation of an attribute whose value is distinct for each instance (object) of the class. Therefore, an instance variable is a specific kind of attribute.

Question 7

1. Methods within a single ShoppingApplication class, such as customer(), order(), and product().
2. Parameters for a single constructor, such as public ShoppingApplication(Customer c, Order o, Product p).
3. Separate classes named Customer, Order, and Product, each with its own attributes and behaviors. (correct answer)
4. Private instance variables within the main method of the application, used to track the application's current state.

Explanation: In object-oriented design, nouns in a problem description often correspond to classes. Each class serves as a blueprint for objects that represent that concept. Therefore, Customer, Order, and Product are excellent candidates for becoming distinct classes in the program design.

Question 8

1. The actions accelerate and brake, which directly modify the car's state.
2. The properties color and currentSpeed, which describe the car's state. (correct answer)
3. The class name Car and the property color, which are fundamental to its identity.
4. The action accelerate and the property color, representing one behavior and one state.

Explanation: Attributes, typically implemented as instance variables, represent the state or properties of an object. In this case, a car's state is described by its color and currentSpeed. The actions accelerate and brake are behaviors, which would be implemented as methods.

Question 9

1. The properties accountNumber and balance, which describe the account's state.
2. The action deposit and the property accountNumber, representing a behavior and a state.
3. The actions deposit and withdraw, which modify the account's state. (correct answer)
4. The action withdraw and the property balance, representing a behavior and a state.

Explanation: Behaviors, implemented as methods, represent the actions an object can perform or that can be performed on it. In this case, deposit and withdraw are the actions that change the state (the balance) of a BankAccount object.

Question 10

1. This design phase automatically generates all the required Java code from the diagrams, which eliminates the need for manual programming.
2. These diagrams are compiled by the Java compiler to check for syntax errors before any code is actually written.
3. This phase allows the team to plan the program's overall structure, define responsibilities for each class, and manage complexity before investing time in implementation. (correct answer)
4. The diagrams created in this phase serve as the final, official user manual for the customers of the completed software.

Explanation: The design phase is a critical step in software development. It allows developers to think through the problem, establish a clear and logical structure for the solution, and identify potential issues before writing code. This planning helps manage complexity and leads to a more robust and maintainable final product.

Question 11

1. Methods like getArea() always execute faster than retrieving the value of an instance variable, improving program performance.
2. This design ensures data consistency; if the radius is changed, the values returned by getArea() and getCircumference() will be correct without needing to manually update other variables. (correct answer)
3. It is not possible in Java to store calculated floating-point values, such as area or circumference, as instance variables; they must be calculated in methods.
4. Storing area and circumference as instance variables would violate encapsulation and require making the radius variable public for them to be calculated.

Explanation: This design avoids data redundancy and potential inconsistency. If area and circumference were also stored as instance variables, any method that changed the radius would also have to remember to update both of those values. By calculating them on demand, the class guarantees that the returned values are always consistent with the current radius.

Question 12

1. Iteration, which involves the process of repeating a set of instructions multiple times to accomplish a task.
2. Abstraction, which involves providing a simplified interface that hides complex underlying implementation details. (correct answer)
3. Variable declaration, which involves the process of assigning a symbolic name to a specific location in computer memory.
4. Conditional logic, which allows a program to make decisions and execute different code paths based on specific criteria.

Explanation: This is a classic analogy for abstraction. A car's dashboard is the public interface to the car's functionality. It abstracts away the complex internal mechanics, allowing the driver to operate the car effectively without needing to be a mechanic. Similarly, in programming, a class's public methods provide a simple interface to its complex internal logic and data.

Question 13

1. The resulting program is often easier for other programmers to read and understand.
2. These design principles entirely eliminate the need to write constructors for a class. (correct answer)
3. Common tasks can be encapsulated in methods, which facilitates code reuse throughout a program.
4. Debugging is simplified because functionality is isolated into smaller, testable units.

Explanation: Procedural abstraction and method decomposition are design principles for a class's behaviors (methods). Constructors have a distinct purpose: to initialize the state of a new object. While a well-designed class will use abstraction for its methods, this does not remove the need for constructors to set up its initial attributes.

Question 14

1. public boolean addToCart(){ if(stockQuantity<=0) return false; stockQuantity--; return true; } (correct answer)
2. public void addToCart(){ stockQuantity++; }
3. private boolean addToCart(){ stockQuantity--; return true; }
4. public int addToCart(){ stockQuantity--; return stockQuantity; }

Explanation: This question tests AP Computer Science A skills, specifically abstraction and program design through implementing methods that manage inventory. The addToCart method should check stock availability, reduce stock by one if possible, and return a boolean indicating success. Choice A is correct because it checks if stockQuantity is zero or less, returns false if no stock, otherwise decrements stockQuantity and returns true, properly implementing inventory management. Choice B is incorrect because it increments stock (stockQuantity++) instead of decrementing it, which is the opposite of removing an item from stock for the cart. To help students: Emphasize the importance of checking preconditions (stock > 0) before modifying state and using appropriate operators (-- for decrement). Practice implementing methods that validate before updating and return success indicators. Watch for: using wrong operators (++ vs --) and forgetting to check boundary conditions.

Question 15

1. All fields private with getter methods for ID and name, and a single setter method for all fields
2. ID field private with only a getter method, name field private with getter and setter methods, GPA field private with getter and updateGPA method (correct answer)
3. All fields public to allow maximum flexibility for different use cases and future requirements
4. ID field protected with getter method, name and GPA fields public with validation in setter methods

Explanation: Option B correctly implements the abstraction requirements: ID is immutable (private with only getter), name is mutable (private with getter/setter), and GPA has controlled modification (private with specialized method). Option A allows inappropriate modification of ID through a general setter. Option C violates encapsulation entirely. Option D uses inappropriate access levels and still allows direct field access.

Question 16

1. Store temperature in Celsius as a public field and provide conversion methods that return calculated values
2. Store temperature in the format of the first value set and provide conversion methods based on stored format
3. Store temperature in Kelvin internally with public methods for setting/getting in Celsius or Fahrenheit, validating against absolute zero (correct answer)
4. Store temperature in both Celsius and Fahrenheit fields to avoid repeated calculations and provide direct access methods

Explanation: Option C demonstrates proper abstraction by hiding the internal representation (Kelvin) while providing a clean interface for common temperature scales. Kelvin naturally prevents below absolute zero, and conversion formulas are simplified. Option A violates encapsulation with public fields. Option B creates inconsistent internal state. Option D violates the single source of truth principle and could lead to synchronization issues.

Question 17

1. Use a single ArrayList with public search methods that iterate through all books
2. Use multiple HashMap collections with public methods that expose the maps for searching
3. Use multiple private HashMap collections with public search methods returning Book copies (correct answer)
4. Use a single HashMap<String, Book> with public methods returning internal references

Explanation: Option C properly encapsulates the data structure choice while providing efficient searches and protecting object integrity by returning copies. Option A is inefficient for large collections. Option B violates encapsulation by exposing internal data structures. Option D is efficient but violates encapsulation by returning internal references and only supports ISBN searching efficiently.

Question 18

1. Whether the internal time representation uses 12-hour or 24-hour format
2. Whether the class provides both 12-hour and 24-hour display formats
3. Whether the time is stored as separate hour/minute fields or total minutes since midnight
4. Whether minute and hour overflow is handled internally or delegated to client code (correct answer)

Explanation: When evaluating object-oriented design quality, abstraction is about hiding implementation details from users while providing a clean, reliable interface. The key question is: what should the class handle internally versus what should users be responsible for? Option D is correct because overflow handling fundamentally determines whether the Clock class provides good abstraction. If the class handles overflow internally (when you add 70 minutes, it automatically converts to 1 hour and 10 minutes, wrapping around midnight as needed), users can interact with the clock naturally without worrying about implementation details. However, if overflow handling is delegated to client code, users must manually check bounds and handle wraparound—this breaks abstraction by exposing implementation concerns and makes the class much harder to use correctly. Option A is wrong because the internal representation format doesn't affect the user interface quality—users interact through methods, not directly with internal storage. Option B is incorrect because display format options actually enhance the interface without compromising abstraction—they're additional features, not abstraction flaws. Option C misses the mark because whether time is stored as separate fields or total minutes is purely an internal implementation detail that doesn't impact how users interact with the class. Remember: good abstraction in object-oriented design means the class handles its own complexity internally. When you see questions about class design quality, ask yourself "Does this force users to understand or manage implementation details?" The option that most impacts user experience and code maintainability will be your answer.

Question 19

public void addItem(Item item) {
    items.add(item);
    totalPrice += item.getPrice();
}

public void removeItem(Item item) {
    if (items.remove(item)) {
        totalPrice -= item.getPrice();
    }
}

1. Remove the totalPrice field and calculate the total dynamically from the items list (correct answer)
2. Make totalPrice public so clients can verify the calculation is correct
3. Add a recalculateTotal() method that clients can call to ensure accuracy
4. Store prices separately in a parallel ArrayList to improve calculation efficiency

Explanation: When you encounter questions about class design and abstraction, focus on the principle of data redundancy and maintaining single sources of truth. Good object-oriented design avoids storing the same information in multiple places where it can become inconsistent. The ShoppingCart class violates abstraction by maintaining redundant data—the totalPrice field duplicates information that's already contained within the items list. This creates a dangerous situation where the total price could become out of sync with the actual items if any modification occurs outside the provided methods or if bugs exist in the update logic. Answer A correctly addresses this by eliminating the redundant totalPrice field and calculating totals dynamically from the authoritative source—the items themselves. This ensures the total is always accurate and removes the possibility of inconsistent state. Answer B makes the problem worse by exposing internal implementation details and violating encapsulation. Making fields public breaks the abstraction barrier that protects clients from implementation changes. Answer C acknowledges the synchronization problem but doesn't solve it—it just shifts responsibility to clients to maintain data consistency, which violates good encapsulation principles. Answer D introduces even more redundancy by creating a second data structure that must stay synchronized with the items list, multiplying the potential for inconsistency. Study tip: On AP Computer Science A, watch for design questions that test whether you can identify redundant data storage. The best solution almost always involves maintaining a single authoritative source of information rather than trying to keep multiple copies synchronized.

Question 20

1. Make the balance field public and rely on client code to check the balance before making withdrawals
2. Use a private balance field with public getter and setter methods, where the setter validates non-negative values
3. Use a private balance field with a public getter method and separate deposit/withdraw methods that validate operations (correct answer)
4. Use a protected balance field with public methods that document the requirement but don't enforce validation

Explanation: Option C demonstrates proper abstraction and encapsulation by hiding the balance field (private) and controlling access through methods that enforce business rules. The withdraw method can check if sufficient funds exist before allowing the operation. Option A violates encapsulation by exposing internal state. Option B allows direct setting of balance, which could bypass business logic. Option D uses protected access and doesn't enforce validation, violating the invariant requirement.