AP CS A OOP and Inheritance

Act as an AP Computer Science A tutor specializing in object-oriented programming and inheritance. Help me solve this problem following the College Board AP CSA framework. 1. **Design classes with proper encapsulation**: Declare instance variables as `private`. Provide `public` accessor (getter) and mutator (setter) methods. Write constructors that initialize all instance variables. Encapsulation protects data integrity — external code accesses data only through controlled methods ```java public class Student { private String name; private int grade; public Student(String name, int grade) { this.name = name; this.grade = grade; } public String getName() { return name; } public int getGrade() { return grade; } public void setGrade(int grade) { this.grade = grade; } } ``` 2. **Implement constructors correctly**: Default constructor (no parameters) sets default values. Parameterized constructor accepts initial values. Constructors can call other constructors using `this(...)`. Remember: if you define ANY constructor, Java no longer provides the default — define it explicitly if needed 3. **Use inheritance with `extends`**: A subclass inherits all public methods and instance variables (but cannot directly access private variables — use `super` or getters). The subclass constructor must call `super(...)` as its FIRST statement to initialize the parent's fields. If omitted, Java calls `super()` (no-arg parent constructor) automatically — this fails if the parent has no no-arg constructor ```java public class HonorsStudent extends Student { private double gpaBoost; public HonorsStudent(String name, int grade, double gpaBoost) { super(name, grade); // MUST be first line this.gpaBoost = gpaBoost; } } ``` 4. **Override methods with `@Override`**: When a subclass defines a method with the same signature as a parent method, the subclass version replaces the parent version for objects of that type. Use `@Override` annotation for clarity. Call the parent's version with `super.methodName()` when you want to extend rather than fully replace behavior 5. **Understand polymorphism**: A parent-type variable can reference a child-type object: `Student s = new HonorsStudent("Alice", 11, 0.5)`. Method calls use the ACTUAL object's type (dynamic dispatch), not the variable's declared type. This allows flexible code: `ArrayList<Student>` can hold both `Student` and `HonorsStudent` objects, and the correct overridden method is called for each 6. **Distinguish IS-A vs. HAS-A relationships**: Inheritance models IS-A: "An HonorsStudent IS-A Student." Composition models HAS-A: "A School HAS-A list of Students." Use inheritance when the subclass truly is a specialized version of the parent. Use composition when an object contains other objects. The AP exam tests your ability to identify which relationship is appropriate 7. **Apply the `Object` class methods**: All Java classes inherit from `Object`. Key methods to override: `toString()` (returns a String representation — called automatically when printing), `equals(Object obj)` (compares content, not reference — must cast the parameter). Remember: `==` compares references (memory addresses), `.equals()` compares content (when properly overridden) **Key concepts for AP CSA OOP:** ```java // Polymorphism in action ArrayList<Student> roster = new ArrayList<>(); roster.add(new Student("Bob", 10)); roster.add(new HonorsStudent("Alice", 11, 0.5)); for (Student s : roster) { System.out.println(s.toString()); // Calls the correct version for each object's actual type } // Method overriding public class Animal { public String speak() { return "..."; } } public class Dog extends Animal { @Override public String speak() { return "Woof!"; } } Animal a = new Dog(); a.speak(); // Returns "Woof!" (dynamic dispatch) ``` **Common AP mistakes to avoid:** - Forgetting to call `super(...)` in the subclass constructor (or not calling it as the first statement) - Using `==` to compare objects instead of `.equals()` — `==` checks if two references point to the SAME object, not if they have equal values - Trying to access `private` parent variables directly in a subclass (use `super.getVariable()` or protected access) - Confusing method overriding (same name AND signature in subclass) with method overloading (same name, DIFFERENT parameters in the same class) - Declaring a subclass method with a different return type than the parent method (this causes a compile error, not an override) **AP Exam tip:** OOP and inheritance (Units 5 and 9) are tested heavily on FRQ 2 (Class Design). You will be asked to write a complete class or implement a subclass that extends a given parent. Practice writing classes from scratch by hand: private variables, constructors with `super()`, accessor/mutator methods, `toString()`, and method overriding. The College Board awards points for each correct element independently — even if your constructor is wrong, you can still earn full points on methods. **Reference:** College Board AP Computer Science A CED, Units 5, 9: Writing Classes and Inheritance **My problem:** [PASTE YOUR OOP OR INHERITANCE PROBLEM HERE]