AP Computer Science a Quiz: Anatomy Of A Class

What this quiz covers

This quiz focuses on Anatomy Of A Class, 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

public class BankAccount {
  // Fields represent state
  private String owner;
  private double balance;

  public BankAccount(String owner, double startingBalance) {
    this.owner = owner;
    balance = startingBalance;
  }

  public String getOwner() { return owner; }
}

// Encapsulation: hide fields, expose methods.
// Inheritance: subclasses can extend BankAccount.
// Polymorphism: overridden methods can change behavior.

1. protected, so any class in package edits it
2. public, so other classes can change it freely
3. private, so only the class accesses it (correct answer)
4. default, so it cannot be accessed at all

Explanation: This question tests AP Computer Science A understanding of access modifiers and encapsulation best practices. The principle of encapsulation dictates that fields should be private to prevent direct external access, with public methods providing controlled access when needed. In the BankAccount class, the owner field contains sensitive account information that should be protected from direct modification, while the getOwner() method provides read-only access. Choice C is correct because private access ensures that only the BankAccount class itself can directly access the owner field, maintaining data integrity and allowing future implementation changes without affecting client code. Choice A is incorrect because protected access would allow any class in the same package or subclasses to modify owner directly, weakening encapsulation. Students should understand that private fields with public getters (and setters when needed) represent the standard Java pattern. Practice identifying which fields need protection and writing appropriate access methods.

Question 2

public class Animal {
  private String name;

  public Animal(String name) {
    this.name = name;
  }

  public String getName() { return name; }

  public void speak() {
    System.out.println("...");
  }
}

public class Dog extends Animal {
  public Dog(String name) { super(name); }

  @Override
  public void speak() {
    System.out.println("Woof");
  }
}

// Encapsulation: name is private and accessed via getName().
// Inheritance: Dog reuses Animal code.
// Polymorphism: speak() can vary by subclass.

1. It lets Dog reuse Animal fields and methods (correct answer)
2. It prevents Dog from overriding any methods
3. It makes all private fields public in Dog
4. It automatically creates extra constructors in Animal

Explanation: This question tests AP Computer Science A understanding of inheritance benefits in object-oriented design. Inheritance creates an 'is-a' relationship where subclasses automatically inherit accessible fields and methods from their superclass, promoting code reuse and establishing logical hierarchies. In the example, Dog extends Animal and inherits the private name field (accessed through getName()) and the speak() method, while only needing to implement Dog-specific behavior like the overridden speak() method. Choice A is correct because it accurately identifies that Dog reuses Animal's fields and methods without rewriting them, demonstrating the primary benefit of inheritance. Choice B is incorrect because inheritance actually enables method overriding (as shown with speak()), not prevents it, which is a fundamental aspect of polymorphism. Teachers should emphasize the super() call in constructors and how inherited members work. Use UML diagrams to visualize inheritance relationships and practice identifying what is inherited versus what must be implemented in subclasses.

Question 3

// BankAccount models a simple account for AP CSA
public class BankAccount {
  // Fields store object state
  private String owner;
  private double balance;

  // Constructor initializes fields
  public BankAccount(String owner, double startingBalance) {
    this.owner = owner;
    balance = startingBalance;
  }

  // Methods provide controlled access/behavior
  public void deposit(double amount) {
    if (amount > 0) balance += amount;
  }

  public boolean withdraw(double amount) {
    if (amount > 0 && amount <= balance) {
      balance -= amount;
      return true;
    }
    return false;
  }

  public double getBalance() { return balance; }
}

// Encapsulation keeps fields hidden and uses public methods.
// Inheritance lets a class extend another class.
// Polymorphism lets overridden methods run based on object type.

1. public, so all classes can edit it
2. protected, so subclasses can edit it
3. private, so only this class accesses it (correct answer)
4. default, so methods auto-protect it

Explanation: This question tests AP Computer Science A understanding of access modifiers and encapsulation principles in Java class design. Encapsulation is a fundamental OOP principle that protects data by restricting direct access to fields and providing controlled access through methods. In the BankAccount class, the balance field stores sensitive financial data that should only be modified through validated methods like deposit() and withdraw(). Choice C is correct because the private modifier ensures that balance can only be accessed within the BankAccount class itself, preventing external classes from directly manipulating this critical data. Choice A (public) is incorrect because it would allow any class to directly modify balance without validation, breaking encapsulation and potentially causing data corruption. Students should understand that private fields with public getter/setter methods represent the standard pattern for encapsulation in Java. Practice identifying which data needs protection and writing appropriate accessor methods to reinforce this concept.

Question 4

public class Animal {
  public void speak() {
    System.out.println("...");
  }
}

public class Dog extends Animal {
  @Override
  public void speak() {
    System.out.println("Woof");
  }
}

public class Cat extends Animal {
  @Override
  public void speak() {
    System.out.println("Meow");
  }
}

class Demo {
  public static void main(String[] args) {
    Animal a1 = new Dog();
    Animal a2 = new Cat();
    a1.speak();
    a2.speak();
  }
}

// Encapsulation: hide fields using private.
// Inheritance: Dog and Cat extend Animal.
// Polymorphism: the same call can run different overridden methods.

1. One method call runs different overridden versions (correct answer)
2. A class must always extend another class
3. Polymorphism means having multiple constructors
4. Overriding makes fields public automatically

Explanation: This question tests AP Computer Science A understanding of polymorphism and method overriding in inheritance hierarchies. Polymorphism allows a single method call to execute different implementations based on the actual object type at runtime, enabling flexible and extensible code design. In the example, Animal references (a1 and a2) point to Dog and Cat objects respectively, and when speak() is called, Java's dynamic binding executes the overridden version in each subclass, printing 'Woof' and 'Meow' instead of '...'. Choice A is correct because it accurately describes how polymorphism enables one method call to run different overridden versions based on the actual object type. Choice C is incorrect because it confuses polymorphism with method overloading (multiple methods with the same name but different parameters), which is a compile-time feature rather than runtime behavior. Students should trace through code execution to see how the same method call produces different results. Use visual representations showing how method calls are resolved at runtime based on object type, not reference type.

Question 5

// Animal is a superclass.
public class Animal {
  public void speak() {
    System.out.println("...");
  }
}

// Dog overrides speak().
public class Dog extends Animal {
  @Override
  public void speak() {
    System.out.println("Woof");
  }
}

// Cat overrides speak().
public class Cat extends Animal {
  @Override
  public void speak() {
    System.out.println("Meow");
  }
}

// Polymorphism: same method call, different behavior.
public class Demo {
  public static void main(String[] args) {
    Animal a1 = new Dog();
    Animal a2 = new Cat();
    a1.speak(); // calls Dog version
    a2.speak(); // calls Cat version
  }
}

// Encapsulation: keep fields private, expose methods.
// Inheritance: Dog and Cat reuse Animal structure.

1. Using multiple constructors with different parameters
2. Calling speak() on Animal references runs overridden methods (correct answer)
3. Making all fields public for easy access
4. Copying methods into subclasses without changes

Explanation: This question tests AP Computer Science A understanding of polymorphism and method overriding in object-oriented programming. Polymorphism allows objects of different types to be treated uniformly through a common interface, enabling the same method call to produce different behaviors based on the actual object type at runtime. In the example, Animal references (a1 and a2) can point to Dog and Cat objects, and when speak() is called, Java's dynamic binding ensures the overridden version in the actual object type executes. Choice B is correct because it accurately describes how polymorphism works: calling speak() on Animal references executes the overridden methods in the subclasses, demonstrating 'one interface, multiple implementations.' Choice A is incorrect because it describes method overloading (multiple constructors with different parameters), not polymorphism. Teachers should use visual demonstrations showing how the same Animal reference can exhibit different behaviors, reinforcing that polymorphism enables flexible, extensible code design.

Question 6

public class Car {
  // Fields (state)
  private String make;
  private String model;
  private int year;

  // Constructor
  public Car(String make, String model, int year) {
    this.make = make;
    this.model = model;
    this.year = year;
  }

  // Methods (behavior)
  public void start() { /* start engine */ }
  public void stop()  { /* stop engine */ }
}

// Encapsulation: fields are private; methods are public.
// Inheritance: a class can extend another class.
// Polymorphism: overridden methods run based on object type.

1. It initializes fields when an object is created (correct answer)
2. It overrides methods from a superclass
3. It deletes objects when they are unused
4. It changes the class name at runtime

Explanation: This question tests AP Computer Science A understanding of constructors and their role in object initialization. Constructors are special methods that execute when objects are created using the 'new' keyword, setting up the initial state of an object by assigning values to its fields. In the Car class example, the constructor takes three parameters (make, model, year) and uses them to initialize the corresponding private fields, ensuring every Car object starts with meaningful data. Choice A is correct because it accurately describes the constructor's primary purpose of initializing fields when an object is instantiated. Choice C is incorrect because it confuses constructors with destructors (which don't exist in Java due to automatic garbage collection), a common misconception among students learning from C++ backgrounds. Teachers should emphasize that constructors have the same name as the class, no return type, and execute automatically during object creation. Use memory diagrams to show how constructors set up object state and practice writing constructors with different parameter lists.

Question 7

public class Car {
  private boolean running;

  public Car() {
    running = false; // constructor sets initial state
  }

  public void start() {
    // behavior changes state safely
    running = true;
  }

  public void stop() {
    running = false;
  }
}

// Encapsulation: running is private; methods change it.
// Inheritance: a subclass could extend Car.
// Polymorphism: a subclass could override start().

1. They provide behavior that updates private state (correct answer)
2. They allow fields to be called like functions
3. They remove the need for constructors entirely
4. They make inheritance impossible in the program

Explanation: This question tests AP Computer Science A understanding of methods as the behavior component of classes and their role in encapsulation. Methods like start() encapsulate behavior that safely modifies an object's private state, ensuring that state changes follow defined rules and maintaining object consistency. In the Car class, start() provides a controlled way to change the private running field from false to true, representing the car's engine state in a meaningful way. Choice A is correct because it identifies that methods provide behavior that updates private state, which is fundamental to object-oriented design where objects have both state (fields) and behavior (methods). Choice C is incorrect because methods complement constructors rather than replace them - constructors initialize state while methods modify it during the object's lifetime. Teachers should emphasize that methods represent what objects can do, while fields represent what objects know. Use real-world analogies and have students design classes where methods model realistic behaviors.

Question 8

public class Animal {
  public void eat() {
    System.out.println("Eating");
  }
}

public class Dog extends Animal {
  public void fetch() {
    System.out.println("Fetching");
  }
}

// Encapsulation: fields would be private (not shown).
// Inheritance: Dog gets eat() without rewriting it.
// Polymorphism: overridden methods can vary (not shown).

1. Dog automatically gains eat() from Animal (correct answer)
2. Dog can access all private fields without methods
3. Dog must redefine eat() or code will not compile
4. Dog becomes an interface that cannot be instantiated

Explanation: This question tests AP Computer Science A understanding of inheritance and code reuse in class hierarchies. Inheritance allows subclasses to automatically acquire non-private members from their superclass without rewriting code, following the DRY (Don't Repeat Yourself) principle. In the example, Dog extends Animal and automatically inherits the eat() method, so Dog objects can call eat() without the method being defined in the Dog class itself. Choice A is correct because it accurately states that Dog automatically gains the eat() method from Animal through inheritance. Choice C is incorrect because inherited methods don't need to be redefined unless you want different behavior - the code compiles and runs perfectly with Dog using Animal's eat() implementation. Students should understand the difference between inheriting a method and overriding it. Practice creating inheritance hierarchies and testing which methods are available in subclasses to reinforce automatic inheritance of non-private members.

Question 9

public class Animal {
  public void speak() { System.out.println("..."); }
}

public class Dog extends Animal {
  @Override
  public void speak() { System.out.println("Woof"); }
}

public class Cat extends Animal {
  @Override
  public void speak() { System.out.println("Meow"); }
}

class Test {
  public static void makeItSpeak(Animal a) {
    a.speak(); // same call, different results
  }
}

// Encapsulation: fields (if any) stay private.
// Inheritance: Dog/Cat extend Animal.
// Polymorphism: Animal reference can call subclass overrides.

1. It allows multiple classes to share the same name
2. It allows one reference type to use many behaviors (correct answer)
3. It requires all fields to be public for access
4. It means constructors replace methods entirely

Explanation: This question tests AP Computer Science A understanding of polymorphism as a core object-oriented principle. Polymorphism allows a single reference type to exhibit multiple behaviors through method overriding, where the actual behavior depends on the object's runtime type, not its compile-time reference type. In the example, the makeItSpeak() method accepts an Animal reference but can invoke Dog's or Cat's overridden speak() method, demonstrating how one interface supports many implementations. Choice B is correct because it accurately describes polymorphism as allowing one reference type (Animal) to use many behaviors (different speak() implementations). Choice A is incorrect because it describes name conflicts or overloading rather than polymorphism - polymorphism is about behavior variation, not naming. Teachers should trace through code execution showing how the same method call produces different outputs. Use debugging tools to show students how Java determines which method to call at runtime based on the actual object type.

Question 10

public class Student {
  // Fields
  private String name;
  private int gradeLevel;

  // Constructor
  public Student(String name, int gradeLevel) {
    this.name = name;
    this.gradeLevel = gradeLevel;
  }

  // Method
  public String getName() { return name; }
}

// Encapsulation: private fields, public getters.
// Inheritance: a class can extend Student (not shown).
// Polymorphism: overridden methods can vary (not shown).

1. It initializes name and gradeLevel for new objects (correct answer)
2. It makes all methods run faster automatically
3. It converts fields into methods at compile time
4. It prevents objects from being created

Explanation: This question tests AP Computer Science A understanding of constructor functionality in object initialization. Constructors are special methods that run automatically when objects are created, setting up the initial state by assigning values to instance fields. In the Student class, the constructor takes name and gradeLevel parameters and uses the 'this' keyword to distinguish between parameters and instance fields with the same names, ensuring proper initialization. Choice A is correct because it accurately describes that the constructor initializes the name and gradeLevel fields for new Student objects. Choice D is incorrect because constructors enable object creation rather than prevent it - a class without accessible constructors would prevent instantiation, which is the opposite of this constructor's purpose. Teachers should emphasize the difference between declaring fields and initializing them in constructors. Practice using the 'this' keyword and explain how constructors differ from regular methods in syntax and purpose.

Question 11

public class BankAccount {
  private String owner;
  private double balance;

  public BankAccount(String owner, double startingBalance) {
    this.owner = owner;
    balance = startingBalance;
  }

  public boolean withdraw(double amount) {
    // Controlled update to state
    if (amount > 0 && amount <= balance) {
      balance -= amount;
      return true;
    }
    return false;
  }

  public double getBalance() { return balance; }
}

// Encapsulation: methods control how balance changes.
// Inheritance: classes can extend BankAccount (not shown).
// Polymorphism: overridden methods can change behavior (not shown).

1. They enforce rules when changing an object's state (correct answer)
2. They allow direct access to private fields from anywhere
3. They rename the class to match the account owner
4. They automatically inherit methods from unrelated classes

Explanation: This question tests AP Computer Science A understanding of encapsulation and the importance of controlled access to object state. Methods like withdraw() serve as gatekeepers that validate and control how an object's internal state changes, maintaining data integrity and enforcing business rules. In the BankAccount example, withdraw() prevents invalid operations by checking that the amount is positive and doesn't exceed the balance, returning a boolean to indicate success or failure. Choice A is correct because it identifies that these methods enforce rules when changing object state, which is the essence of encapsulation and data protection. Choice B is incorrect because it contradicts the purpose of encapsulation - methods provide controlled access, not direct access to private fields. Students should practice writing validation logic in methods and understand why direct field access is dangerous. Create scenarios where uncontrolled access would break program logic to reinforce the importance of accessor and mutator methods.

Question 12

public class Animal {
  public void speak() { System.out.println("..."); }
}

public class Dog extends Animal {
  @Override
  public void speak() { System.out.println("Woof"); }
}

public class Cat extends Animal {
  @Override
  public void speak() { System.out.println("Meow"); }
}

public class Demo {
  public static void makeItSpeak(Animal a) {
    a.speak(); // same call, different results
  }
}

// Encapsulation: fields would be private with public methods.
// Inheritance: Dog/Cat extend Animal.

1. A method call uses the object's actual class at runtime (correct answer)
2. A subclass automatically copies fields as public
3. A constructor runs multiple times per method call
4. A field can override a method with the same name

Explanation: This question tests AP Computer Science A understanding of polymorphism and dynamic method binding in Java. Polymorphism enables a single method call to exhibit different behaviors based on the actual object type at runtime, even when accessed through a superclass reference - this is the essence of 'many forms' in object-oriented programming. In the example, the makeItSpeak() method accepts an Animal parameter, but when a.speak() is called, Java determines at runtime whether the object is actually a Dog or Cat, executing the appropriate overridden version of speak(). Choice A is correct because it accurately describes dynamic binding: the method call uses the object's actual class (Dog or Cat) at runtime, not the reference type (Animal). Choice D is incorrect because fields and methods exist in separate namespaces in Java - a field cannot override a method, and this statement demonstrates a fundamental misunderstanding of Java's structure. Students should trace through polymorphic method calls using debuggers to see runtime type determination in action.

Question 13

// Car represents a real-world car object.
public class Car {
  // Fields describe state
  private String make;
  private String model;
  private int year;

  // Constructor
  public Car(String make, String model, int year) {
    this.make = make;
    this.model = model;
    this.year = year;
  }

  // Methods describe behavior
  public void start() {
    // start the car
  }

  public void stop() {
    // stop the car
  }
}

// Encapsulation keeps fields private and exposes behavior via methods.
// Inheritance and polymorphism allow subclasses to reuse and override methods.

1. It initializes the object's fields at creation (correct answer)
2. It overrides methods from a superclass
3. It deletes objects when they are unused
4. It changes the class name at runtime

Explanation: This question tests AP Computer Science A understanding of constructors and their role in object initialization within Java classes. Constructors are special methods that execute when an object is created using the 'new' keyword, setting up the initial state of the object by assigning values to its fields. In the Car class example, the constructor takes three parameters (make, model, year) and uses them to initialize the corresponding private fields, ensuring every Car object starts with meaningful data. Choice A is correct because it accurately describes the constructor's primary purpose of initializing the object's fields at the moment of creation. Choice C is incorrect because Java uses automatic garbage collection rather than explicit destructors, and constructors have nothing to do with object deletion. Students should practice writing constructors that validate input parameters and understand the difference between constructors and regular methods, noting that constructors have no return type and must match the class name.

Question 14

1. All instance variables are declared as public to allow direct access, with public methods that perform validation before modifying the variables
2. All instance variables are declared as private, with public getter methods for all variables and public setter methods that include appropriate validation (correct answer)
3. All instance variables are declared as protected, with package-private methods that can be accessed by related classes in the banking system
4. All instance variables are declared as private, with only public getter methods and no setter methods to prevent any modification after object creation

Explanation: Option B correctly implements encapsulation by making instance variables private (hiding internal state) while providing controlled access through public getter methods and validated setter methods. This allows the class to maintain control over how its data is accessed and modified. Option A violates encapsulation by making variables public. Option C uses protected access which is less secure than private. Option D is too restrictive as it prevents any modification, which would make the class impractical for a bank account that needs balance updates.

Question 15

public Student(String n, int g) {
    name = n;
    grade = g;
    studentCount++;
}

public static int getStudentCount() {
    return studentCount;
}

public void updateGrade(int newGrade) {
    grade = newGrade;
}

1. The code will compile and run successfully, returning the current value of studentCount since static variables are always accessible
2. The code will compile but throw a runtime exception because static variables cannot be accessed using the class name
3. The code will not compile because studentCount is declared as private, preventing direct access from outside the class (correct answer)
4. The code will compile and run successfully, but will always return 0 because static variables are reset each time they are accessed

Explanation: Option C is correct because studentCount is declared as private, which means it cannot be accessed directly from outside the class, regardless of whether it's static or not. The access modifier (private) takes precedence over the static keyword for access control. Option A is incorrect because private static variables are not accessible from outside the class. Option B is wrong because static variables can be accessed using the class name, but only if they have appropriate access modifiers. Option D is incorrect because static variables maintain their values and are not reset when accessed.

Question 16

1. public Rectangle(double l, double w) { length = l; width = w; }
2. public Rectangle(double l, double w) { length = Math.abs(l); width = Math.abs(w); }
3. public Rectangle(double l, double w) { if (l > 0 && w > 0) { length = l; width = w; } }
4. public Rectangle(double l, double w) { if (l <= 0 || w <= 0) throw new IllegalArgumentException(); length = l; width = w; } (correct answer)

Explanation: Option D best follows defensive programming practices by explicitly checking for invalid input and throwing an appropriate exception when negative or zero values are provided. This makes the error condition clear and forces the calling code to handle invalid input properly. Option A provides no validation. Option B silently converts negative values to positive ones, which could mask programming errors. Option C checks for validity but leaves the instance variables uninitialized when invalid input is provided, creating an object in an undefined state.

Question 17

1. Overloaded methods must have different return types and the same parameter list to distinguish them during compilation
2. Overloaded methods are distinguished by their parameter lists during compilation, and the appropriate method is selected at runtime based on actual object types
3. Overloaded methods are distinguished by their parameter lists during compilation, and method selection is resolved at compile time based on declared parameter types (correct answer)
4. Overloaded methods must have the same return type but different access modifiers, and selection occurs at runtime based on the calling object's state

Explanation: Option C is correct because method overloading is resolved at compile time based on the method signature (name and parameter list), not at runtime. The compiler determines which overloaded method to call based on the declared types of the arguments passed. Option A is incorrect because overloaded methods are distinguished by parameter lists, not return types, and they should have different parameter lists. Option B incorrectly states that method selection happens at runtime (that's method overriding, not overloading). Option D is incorrect because overloaded methods don't require the same return type or different access modifiers, and selection doesn't occur at runtime.

Question 18

public BankAccount(String accNum) {
    accountNumber = accNum;
    balance = 0.0;
}

public void deposit(double amount) {
    balance += amount;
}

public boolean withdraw(double amount) {
    if (amount <= balance) {
        balance -= amount;
        return true;
    }
    return false;
}

public String getAccountInfo() {
    return "Account: " + accountNumber + ", Balance: $" + balance;
}

1. Add a getBalance() method to provide direct access to the balance without requiring string parsing from getAccountInfo()
2. Add validation in the deposit method to reject negative amounts and throw an IllegalArgumentException for invalid deposits (correct answer)
3. Change the balance variable from double to int to avoid floating-point precision errors in financial calculations
4. Add a static variable to track the total number of accounts created and increment it in the constructor

Explanation: Option B best improves robustness by adding input validation to prevent logical errors. Currently, the deposit method accepts negative amounts, which could decrease the balance inappropriately - this is a significant logical flaw that should be prevented. Option A adds convenience but doesn't improve robustness against errors. Option C suggests using int instead of double, but this would actually limit functionality by preventing fractional currency amounts (cents). Option D adds tracking functionality but doesn't address any existing robustness issues in the current code.

Question 19

public Circle(double r) {
    radius = r;
}

public double getArea() {
    return PI * radius * radius;
}

public static double getCircumference(double r) {
    return 2 * PI * r;
}

public void scale(double factor) {
    radius *= factor;
}

1. Circle c = new Circle(5.0); double area = c.getArea();
2. double circumference = Circle.getCircumference(3.0);
3. Circle c = new Circle(2.0); double circumference = c.getCircumference(4.0);
4. Circle c1 = new Circle(1.0); c1.scale(2.5); double newArea = Circle.getArea(); (correct answer)

Explanation: Option D will cause a compilation error because getArea() is an instance method that requires an object instance to be called, but it's being called statically using the class name Circle.getArea(). Instance methods cannot be called without an object instance. Option A correctly calls an instance method on an object. Option B correctly calls a static method using the class name. Option C shows that static methods can be called on object instances (though not conventional, it's legal in Java).

Question 20

public Counter() {
    value = 0;
    totalCounters++;
}

public Counter(int initialValue) {
    value = initialValue;
    totalCounters++;
}

public void increment() {
    value++;
}

public int getValue() {
    return value;
}

public static int getTotalCounters() {
    return totalCounters;
}

1. 2 2 (correct answer)
2. 2 1
3. 7 2
4. 1 2

Explanation: Option A is correct. The code creates two Counter objects (c1 and c2), so totalCounters becomes 2. Object c1 starts with value 0 (default constructor) and is incremented twice, making its value 2. The getValue() method returns c1's value (2), and getTotalCounters() returns the static variable totalCounters (2). Option B incorrectly shows totalCounters as 1. Option C incorrectly adds c1's value to c2's initial value. Option D shows c1's value as 1, missing one increment operation.