Polymorphism: Many Forms

Active learning works for polymorphism because students need to see, touch, and manipulate the concept to grasp how different objects behave through a shared interface. Abstract ideas like runtime method binding become clear when learners build, predict, and discuss concrete examples.

• 11th Grade
• Computer Science
• 3 activities
• 30 min–60 min

Project-Based Learning

⏱ 60 min·Small Groups

Format Name: Polymorphism Playground

Students create a base class (e.g., 'Animal') with a method (e.g., 'makeSound'). Then, they create subclasses (e.g., 'Dog', 'Cat', 'Cow') that override the 'makeSound' method. Finally, they use a list or array of the base class type to store objects of the subclasses and call the 'makeSound' method on each, observing the different outputs.

Prepare & details

Explain how polymorphism allows a single interface to represent different underlying forms.

Facilitation Tip: During Build It: Polymorphic Shape Renderer, circulate and ask each pair to explain how their Circle and Rectangle classes are responding to the same draw() call despite their differences.

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·Individual

Format Name: Method Overloading Challenge

Present students with a scenario requiring a single function name to perform slightly different actions based on input types or numbers (e.g., a 'calculateArea' function for circles, rectangles, and triangles). Students implement these overloaded methods and test their functionality.

Prepare & details

Analyze the role of method overriding and overloading in achieving polymorphism.

Facilitation Tip: During Code Reading: Predict the Output, pause after each student shares their prediction and have the pair defend their reasoning using the code on the board.

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

⏱ 30 min·Small Groups

Format Name: Polymorphic Design Discussion

Provide students with a simple software design problem (e.g., a system for processing different types of payments). In small groups, they brainstorm how polymorphism could be used to handle various payment methods (credit card, PayPal, check) efficiently and extendably.

Prepare & details

Construct code examples demonstrating the power and flexibility of polymorphic behavior.

Facilitation Tip: During Think-Pair-Share: Overriding vs. Overloading, provide a printed table with columns for 'compile-time' and 'runtime' so students physically mark where each concept belongs.

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 by modeling polymorphism with a live demo: create a list of Shape objects and call draw() on each one. Show the output side-by-side so students see the same method name producing different behaviors. Emphasize that polymorphism is a design tool, not a syntax trick. Avoid jumping straight to inheritance—let students discover when it’s helpful through the activities.

What to Expect

Successful learning looks like students confidently explaining why polymorphism simplifies code and correctly predicting which method version will execute in a given scenario. They should also distinguish between overloading and overriding without confusion.

Watch Out for These Misconceptions

Common Misconception

During Think-Pair-Share: Overriding vs. Overloading, watch for students who conflate method overloading with polymorphism.

What to Teach Instead

Use the printed table from the activity to have students physically move sticky notes labeled 'overloading' and 'overriding' under the correct columns, then ask them to write one sentence explaining why overloading is compile-time based on argument types.

Common Misconception

During Build It: Polymorphic Shape Renderer, watch for students who think polymorphism requires inheritance.

What to Teach Instead

Have students modify their code to remove any explicit inheritance (e.g., delete 'extends Shape') and rerun the program. When it still works, ask them to explain how duck typing or interfaces made it possible.

Common Misconception

During Code Reading: Predict the Output, watch for students who believe polymorphism makes code harder to debug because the method called is unclear.

What to Teach Instead

After they predict the output, ask them to trace how the JVM selects the correct method version at runtime. Then challenge them to rewrite the code without polymorphism and compare the two versions to see which is more readable.

Assessment Ideas

Exit Ticket

After Build It: Polymorphic Shape Renderer, provide a code snippet with a superclass Animal and two subclasses (Dog, Cat) that override makeSound(). Ask students to write the expected output when makeSound() is called on an Animal reference pointing to a Dog object, and explain their reasoning in one sentence.

Quick Check

During Think-Pair-Share: Overriding vs. Overloading, ask students to hold up one finger for overloading and two fingers for overriding when you display the code snippets `save(File f)` and `save(String path)`. Circulate to check responses.

Discussion Prompt

During Code Reading: Predict the Output, pose the question: 'If the system needs to add a new subclass Triangle to the existing Shape hierarchy, how does polymorphism protect the existing code that calls draw()?' Have students discuss in pairs and share one idea before moving on.

Extensions & Scaffolding

• Challenge: Ask early finishers to add a new shape (e.g., Hexagon) to their renderer without modifying the rendering loop or the interface.
• Scaffolding: Provide pre-written method stubs for students who struggle with structure, focusing their energy on implementing draw() uniquely in each class.
• Deeper: Invite students to research how polymorphism appears in real-world systems like GUI frameworks or game engines and present a 2-minute example.