Class Hierarchies and Inheritance

Active learning works well for class hierarchies and inheritance because students need to struggle through concrete design decisions to truly grasp abstraction, reuse, and flexibility. By building systems together, they confront the trade-offs of deep inheritance trees and the power of shared logic in real time.

• Grade 11
• Computer Science
• 4 activities
• 25 min–50 min

Learning Objectives

1. Design a simple class hierarchy to model a collection of related real-world objects, demonstrating inheritance.
2. Analyze existing code to identify opportunities for applying inheritance to reduce redundancy and improve maintainability.
3. Compare and contrast the use of inheritance versus composition in designing software solutions.
4. Evaluate the potential drawbacks of deep inheritance trees, such as increased coupling and reduced flexibility.
5. Create a program that utilizes abstract classes or interfaces to define common behaviors for a hierarchy.

Project-Based Learning

⏱ 35 min·Pairs

Pair Programming: Shape Hierarchy Build

Pairs start with a Shape parent class including area and perimeter methods. They create Circle and Rectangle children that override these with specific formulas. Finally, they instantiate objects and test polymorphism by calling methods on a list of shapes.

Prepare & details

How can we design a class hierarchy that is flexible enough for future requirements?

Facilitation Tip: During Pair Programming: Shape Hierarchy Build, circulate and ask each pair to explain why they chose a particular attribute or method for their child class over the parent.

Setup: Flexible workspace with access to materials and technology

Materials: Project brief with driving question, Planning template and timeline, Rubric with milestones, Presentation materials

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

Project-Based Learning

⏱ 45 min·Small Groups

Small Group Refactor: Deep Tree Challenge

Provide code with a four-level inheritance tree modeling employees. Groups identify redundancy and fragility, then refactor to a two-level hierarchy using composition where suitable. Groups present changes and trade-offs to the class.

Prepare & details

What are the dangers of deep inheritance trees in large software projects?

Facilitation Tip: For the Small Group Refactor: Deep Tree Challenge, provide a starter hierarchy that is already too deep and ask groups to measure lines of code before and after refactoring to composition.

Setup: Flexible workspace with access to materials and technology

Materials: Project brief with driving question, Planning template and timeline, Rubric with milestones, Presentation materials

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

Project-Based Learning

⏱ 50 min·Whole Class

Whole Class Design: Animal Kingdom System

As a class, brainstorm a hierarchy for zoo animals with Mammal and Bird parents. Assign subgroups to code one branch, integrate via shared drive, and run simulations to demonstrate inheritance in action.

Prepare & details

How does inheritance promote the principle of DRY (Don't Repeat Yourself)?

Facilitation Tip: In the Whole Class Design: Animal Kingdom System, interrupt once to ask each table to share one method they kept in the parent class and one they moved to a child, then make the class list visible to the whole room.

Setup: Flexible workspace with access to materials and technology

Materials: Project brief with driving question, Planning template and timeline, Rubric with milestones, Presentation materials

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

Project-Based Learning

⏱ 25 min·Individual

Individual Debug: Inheritance Errors Hunt

Students receive broken hierarchy code with issues like inaccessible members or wrong overrides. Individually, they fix errors, add tests, and explain changes in a short journal entry.

Prepare & details

How can we design a class hierarchy that is flexible enough for future requirements?

Facilitation Tip: While running the Individual Debug: Inheritance Errors Hunt, require students to write the exact error message they get when trying to access a private field from a child class and explain why it happened.

Setup: Flexible workspace with access to materials and technology

Materials: Project brief with driving question, Planning template and timeline, Rubric with milestones, Presentation materials

• Apply
• Analyze
• Evaluate
• Create
• Self-Management
• Relationship Skills
• Decision-Making

Teaching This Topic

Start with shallow hierarchies to build confidence, then intentionally introduce deep ones to surface pain points. Use pair programming to model professional collaboration, and always debrief refactoring exercises by having students articulate the impact on future changes. Avoid rushing to composition; let students feel the maintenance burden first so they can choose the right tool.

What to Expect

Successful learning looks like students confidently designing parent-child relationships that reduce duplication without creating rigid dependencies. You will see them discuss access modifiers, justify overrides, and compare inheritance with composition in small-group settings.

Watch Out for These Misconceptions

Common Misconception

During Pair Programming: Shape Hierarchy Build, watch for students who create very deep hierarchies without discussing the trade-offs.

What to Teach Instead

Ask each pair to count the number of classes and methods in their hierarchy, then prompt them to discuss how adding one more child class would affect future changes. Guide them to consider alternatives during the next activity.

Common Misconception

During Individual Debug: Inheritance Errors Hunt, watch for students who assume all parent members are available in the child class.

What to Teach Instead

Have students try to access a private field from a child class and observe the compiler error. Use this moment to discuss access modifiers and encapsulation, then ask them to modify the parent class to make the field protected.

Common Misconception

During Small Group Refactor: Deep Tree Challenge, watch for students who override methods unnecessarily to share code.

What to Teach Instead

Ask groups to identify methods that do not need overrides and keep them in the parent class. Then have them compare the refactored code size to the original and discuss when overrides are truly useful.

Assessment Ideas

Quick Check

After Pair Programming: Shape Hierarchy Build, ask each pair to present their hierarchy and explain one attribute or method they placed in the parent class and one they kept in the child class. Listen for evidence that they understand shared vs unique features.

Discussion Prompt

During Small Group Refactor: Deep Tree Challenge, circulate and listen for groups that discuss using composition instead of inheritance. After they present their refactored code, ask them to explain why they chose composition and what benefits they see in future changes.

Exit Ticket

After Individual Debug: Inheritance Errors Hunt, give students a short code snippet with inheritance and ask them to write the output and explain, in one sentence, how inheritance reduced code duplication compared to writing separate classes for each child.

Extensions & Scaffolding

• Challenge: Ask students to design a third level of hierarchy (e.g., ElectricCar under Car) and explain how this affects testing and extensibility.
• Scaffolding: Provide a starter diagram with two classes already connected; ask students to add a third class with one inherited and one new method.
• Deeper exploration: Introduce protected vs private modifiers and have students redesign a hierarchy to deliberately expose or hide members, then discuss the security and maintenance implications.

Key Vocabulary

Inheritance	A mechanism where a new class (child or subclass) derives properties and behaviors from an existing class (parent or superclass).
Superclass (Parent Class)	The class whose features are inherited by another class. It represents a more general concept.
Subclass (Child Class)	The class that inherits features from a superclass. It represents a more specific concept.
Method Overriding	When a subclass provides a specific implementation of a method that is already defined in its superclass.
Polymorphism	The ability of an object to take on many forms, often achieved through inheritance, allowing objects of different subclasses to be treated as objects of their common superclass.