Computer Science · 11th Grade

Active learning ideas

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.

• Common Core State Standards
• CSTA: 3B-AP-14
• CSTA: 3B-AP-15

• 30–60 min
• Pairs → Whole Class
• 3 activities

Activity 01

• 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.

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.

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

Activity 02

• 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.

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.

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

Activity 03

• 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.

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.

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

A few notes on teaching this unit

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.

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

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

  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.

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

  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.

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

  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.

---

Methods used in this brief

• Project-Based Learning