Computer Science · 12th Grade

Active learning ideas

OOP Principles: Encapsulation and Abstraction

Active learning works well for inheritance and polymorphism because these concepts require students to see relationships between classes and objects in concrete ways. Students need to manipulate code, discuss design choices, and role-play scenarios to truly grasp how child classes extend parents and how different objects can share common behaviors.

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

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

Activity 01

• Inquiry Circle
• 45 min · Small Groups

Inquiry Circle: The Zoo Hierarchy

Groups design a class hierarchy for a zoo management system. They must decide which traits belong in a general 'Animal' class and which are specific to 'Mammal' or 'Bird.' They then present their diagrams to the class to discuss where they placed specific methods like 'makeSound()'.

Explain how abstraction allows developers to change internal logic without breaking external systems.

Facilitation Tip

For The Zoo Hierarchy, assign each group specific animal types to research so they must examine shared traits and unique behaviors before coding.

What to look for

Present students with a simple class definition. Ask them to identify which members are good candidates for being private (data hiding) and which should be public (methods for interaction). Then, ask them to write a brief justification for their choices, referencing encapsulation.

• Analyze
• Evaluate
• Create
• Self-Management
• Self-Awareness

Activity 02

• Role Play
• 30 min · Small Groups

Role Play: The Polymorphic Remote Control

One student acts as a 'Remote Control' interface with buttons like 'Power' and 'Volume.' Other students act as different 'Devices' (TV, Radio, Fan). The Remote student 'calls' a method, and each Device student must perform their specific version of that action, demonstrating polymorphism in action.

Analyze the benefits of encapsulation in maintaining data integrity and reducing complexity.

Facilitation Tip

During The Polymorphic Remote Control, have students physically act out the remote’s interaction with devices to reinforce the idea of shared interfaces.

What to look for

Pose the question: 'Imagine you are building a library system. How would you use abstraction to allow new types of media (like DVDs or e-books) to be added later without changing the core borrowing or returning logic?' Facilitate a class discussion where students propose solutions using abstract concepts.

• Apply
• Analyze
• Evaluate
• Social Awareness
• Self-Awareness

Activity 03

• Formal Debate
• 40 min · Whole Class

Formal Debate: Inheritance vs. Composition

Present a scenario where a 'Car' needs an 'Engine.' Half the class argues that a Car *is* a type of Engine (Inheritance), while the other half argues a Car *has* an Engine (Composition). This helps students understand the nuances of software design relationships.

Construct a class design that effectively utilizes both encapsulation and abstraction.

Facilitation Tip

In Structured Debate: Inheritance vs. Composition, provide each side with a pre-written code snippet that highlights the strengths of their approach.

What to look for

Provide students with a scenario where a class's internal data is modified incorrectly. Ask them to write one sentence explaining how encapsulation could have prevented this issue and one sentence explaining how abstraction might simplify the interaction with that class.

• Analyze
• Evaluate
• Create
• Self-Management
• Decision-Making

A few notes on teaching this unit

Start by teaching encapsulation through data hiding in simple classes, then introduce inheritance as a way to extend functionality. Use analogies like family trees to explain hierarchies, but transition quickly to code so students see the practical implications. Avoid overwhelming students with abstract theory before they’ve practiced with tangible examples.

Successful learning looks like students confidently designing class hierarchies, explaining access modifiers with examples, and distinguishing inheritance from polymorphism in both code and real-world analogies. They should be able to justify their design decisions using encapsulation and abstraction principles.

---

Watch Out for These Misconceptions

• During The Zoo Hierarchy, watch for students assuming all animal attributes should be public because they are part of the class hierarchy.

  Use the starter code to show compiler errors when accessing private fields from subclasses, then guide them to change 'private' to 'protected' or create public getter methods.

• During The Polymorphic Remote Control, watch for students conflating inheritance with polymorphism, assuming that only subclasses can use the same interface.

  Have students implement an interface without any inheritance, then demonstrate how different unrelated classes can respond to the same method calls.

---

Methods used in this brief

• Inquiry Circle
• Role Play
• Formal Debate