AP Computer Science A
Unit 9: Inheritance
8 topics to cover in this unit
Watch Video
AI-generated review video covering all topics
Watch NowStudy Notes
Follow-along note packet with fill-in-the-blank
Start NotesTake Quiz
20 AP-style questions to test your understanding
Start QuizUnit Outline
Creating Superclass and Subclass Relationships
Alright, buckle up! This is where we learn how to create a family tree for our classes. Inheritance is a HUGE concept in Object-Oriented Programming (OOP) that allows us to build new classes (subclasses) based on existing ones (superclasses), inheriting their characteristics and behaviors. Think of it like a blueprint for a house: you can have a general blueprint (superclass) and then create specific, fancier blueprints (subclasses) that inherit all the basic features but add their own unique twists. This is all about the 'is-a' relationship – a Car 'is-a' Vehicle.
- Confusing which class is the superclass and which is the subclass.
- Believing a subclass inherits private members directly (it inherits them but cannot access them directly).
- Thinking a subclass can inherit from multiple superclasses in Java (it can only extend one).
Calling Constructors of Superclasses
When a subclass object is created, its superclass part also needs to be initialized! It's like building a new car model: you first need the basic frame (superclass constructor), and *then* you can add the custom paint job and interior (subclass constructor). Java handles this with a special rule: the superclass constructor *must* be called before the subclass constructor finishes. We'll see how to explicitly call specific superclass constructors using the `super()` keyword.
- Forgetting to include `super()` when a superclass only has parameterized constructors.
- Incorrectly placing the `super()` call somewhere other than the first line of the constructor.
- Thinking `super()` is *always* required explicitly, even if the superclass has a no-argument constructor (Java adds it implicitly then).
Overriding Methods
Sometimes, a subclass wants to do things a little differently than its superclass. Maybe your `Dog` class has an `makeSound()` method, but you don't want it to just 'make a generic sound' like its `Animal` superclass; you want it to 'bark'! Overriding is how a subclass provides its own specific implementation for a method that is already defined in its superclass. It's like saying, 'Hey, I know what you do, but *I'm* going to do it *my* way!'
- Confusing method overriding with method overloading (different method signatures vs. same signature).
- Changing the return type or parameters of an overridden method, leading to an overload instead of an override, or a compile-time error.
- Forgetting that static methods cannot be overridden (they can be 'hidden').
super Keyword
The `super` keyword is your best friend when working with inheritance! It's how you explicitly refer to the superclass's members. We saw `super()` for constructors, but you can also use `super.methodName()` to call an overridden method from the superclass within the subclass. It's like saying, 'I'm doing it my way, but first, let's see how my parent class does it!'
- Confusing `this` (referring to the current object) with `super` (referring to the superclass's members).
- Trying to use `super` to access private fields or methods of the superclass.
- Believing `super` can be used to access superclass *fields* directly if they are shadowed by subclass fields (it can, but usually better practice is to use getter methods).
Polymorphism
Get ready for one of the coolest concepts in OOP: Polymorphism! It literally means 'many forms.' This is the ability of an object to take on many forms. In Java, it means that a superclass reference variable can refer to an object of any of its subclasses. This allows us to write more flexible and generic code. Think of it like a remote control: it can control different brands of TVs, as long as they all implement the basic 'TV' functionality. It's a game-changer for designing robust systems!
- Thinking a superclass reference can call methods that are *only* defined in the subclass (without casting).
- Confusing which method will execute when polymorphism is involved (it's always the object's actual class method if overridden).
- Not understanding that polymorphism allows for more flexible code, especially with collections of objects.
Object Hierarchy
Did you know that *every* class in Java implicitly or explicitly extends the `Object` class? That's right, `Object` is the grand progenitor of all classes! This means every object in Java has access to the methods defined in the `Object` class, like `toString()` and `equals()`. Understanding this universal parent helps us grasp the fundamental structure of Java's class hierarchy and why certain methods are available to all objects.
- Forgetting that `Object` is the ultimate superclass and its methods are available to all classes.
- Not understanding the default behavior of `equals()` (checks for reference equality) and `toString()` (returns class name and hash code) if not overridden.
- Incorrectly overriding `equals()` without also overriding `hashCode()` (though `hashCode()` is less frequently tested on the AP exam directly).
Abstract Classes and Methods
Sometimes, you want to define a general concept but don't want anyone to create an *actual* object of that general type. For example, a `Shape` class might be too generic to instantiate directly, but you want all shapes to have an `calculateArea()` method. Enter abstract classes! They are like incomplete blueprints that *must* be extended by concrete subclasses, which then provide the missing implementations. Abstract methods are declared but not defined, forcing subclasses to implement them.
- Attempting to create an object of an abstract class (it will result in a compile-time error).
- Forgetting to implement all abstract methods in a concrete subclass (the subclass will also have to be declared abstract).
- Confusing abstract classes with interfaces (abstract classes can have implemented methods and instance variables, interfaces cannot).
Interfaces
Interfaces are another powerful tool for achieving abstraction and polymorphism! Think of an interface as a 'contract' or a list of behaviors. A class that 'implements' an interface promises to provide implementations for all the methods declared in that interface. It's like saying, 'I guarantee I can do these things!' This allows for multiple inheritance of *type* (a class can implement multiple interfaces) and helps define common behaviors across unrelated classes. For example, `Comparable` is a famous interface that allows objects to be compared.
- Confusing interfaces with abstract classes (interfaces are purely abstract, no instance variables, all methods implicitly public abstract).
- Forgetting to implement all methods declared in an interface (will result in a compile-time error unless the class is also abstract).
- Thinking an interface can have constructors or instance variables (it cannot).
Key Terms
Key Concepts
- Code reuse and hierarchical organization of classes.
- A subclass inherits all public and protected members (fields and methods) from its superclass.
- The superclass constructor is always called before the subclass constructor.
- The `super()` call must be the first statement in a subclass constructor if you want to explicitly call a specific superclass constructor.
- An overridden method must have the exact same method signature (name, parameter types, and order) and return type as the superclass method.
- The access modifier for an overridden method cannot be more restrictive than the superclass method.
- The `super` keyword allows a subclass to call a constructor of its superclass.
- It also allows a subclass to access public and protected methods of its superclass, even if they have been overridden.
- A reference variable of a superclass type can refer to an object of its subclass type (upcasting).
- When an overridden method is called using a superclass reference, the version of the method in the *actual object's class* (subclass) is executed at runtime (dynamic method dispatch).
- All classes in Java are descendants of the `Object` class.
- Methods like `toString()` and `equals()` are inherited from `Object` and can be overridden to provide specific behavior for a class.
- An abstract class cannot be instantiated directly; it must be subclassed.
- An abstract method has no implementation and forces concrete subclasses to provide one.
- An interface specifies a set of methods that a class must implement, without providing any implementation itself.
- A class can implement multiple interfaces, allowing it to conform to multiple 'contracts' or types.
Cross-Unit Connections
- Unit 2: Objects and Classes – Inheritance builds directly upon the foundational concepts of defining classes and creating objects. It extends how classes relate to each other.
- Unit 4: Writing Classes – Designing classes and their members is a prerequisite. Inheritance allows for more sophisticated class design and code reuse.
- Unit 5: Writing Classes Part 2 – The distinction between method overloading (same class, different signatures) and method overriding (superclass/subclass, same signature) is crucial.
- Unit 6: Array/ArrayList – Polymorphism shines when storing objects of different but related types in a single array or ArrayList (e.g., an `ArrayList<Animal>` holding `Dog`, `Cat`, and `Bird` objects).
- Unit 10: Recursion – While not a direct conceptual link, understanding object relationships and hierarchies can be important in designing recursive algorithms that operate on complex data structures which might utilize inheritance (e.g., tree structures where nodes are polymorphic).