Computer Science · Grade 11

Active learning ideas

Encapsulation and Data Privacy

Active learning works for encapsulation because students need to experience the frustration of broken access and the clarity of controlled data flow. When they try to modify private fields directly in the Broken vs Protected Class activity, they feel the need for getters and setters firsthand. This hands-on approach makes the purpose of access modifiers concrete and memorable.

• Ontario Curriculum Expectations
• CS.HS.P.3
• CS.HS.D.1

• 25–45 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Problem-Based Learning
• 30 min · Pairs

Pair Programming: Broken vs Protected Class

Pairs code a simple Inventory class first with public fields, allowing invalid changes like negative stock. Then refactor to private fields with getter/setter methods and validation. Partners test each version and discuss differences in reliability.

Why is it important to hide the internal implementation details of a class?

Facilitation Tip

In Pair Programming: Broken vs Protected Class, ask one partner to try accessing private fields directly while the other explains the compile error to reinforce the concept.

What to look for

Present students with short code snippets. Ask them to identify which members are public and which are private, and to explain why a particular access attempt would result in an error. For example: 'In this `Car` class, why can we directly change `car.speed` but not `car.engineStatus'?

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

Activity 02

• Problem-Based Learning
• 45 min · Small Groups

Small Groups: Secure User Profile Design

Groups design a UserProfile class with private email and age, public methods for updates with checks (e.g., valid email format). They simulate external code attempting direct access and demonstrate failures. Groups present one security feature each.

How does encapsulation help in debugging and maintaining large scale systems?

Facilitation Tip

For Secure User Profile Design, provide a starter template with public and private fields to guide students toward thoughtful access design.

What to look for

Provide students with a scenario, such as a `UserProfile` class. Ask them to list one piece of data that should be private and explain why, and to name one public method that would be needed to interact with that private data.

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

Activity 03

• Problem-Based Learning
• 35 min · Whole Class

Whole Class: Encapsulation Debug Challenge

Project buggy code with exposed data causing errors on the board or shared screen. Class votes on fixes, then codes in editor with access modifiers. Discuss how encapsulation prevents similar issues in teams.

What happens to system security when internal data is exposed to external modification?

Facilitation Tip

During Encapsulation Debug Challenge, circulate and ask groups to explain their fix in terms of data integrity, not just 'it works now.'

What to look for

Facilitate a class discussion using this prompt: 'Imagine you are building a system for managing student grades. What are the risks if the `grade` attribute for each student is public? How would using private attributes and public methods like `setGrade(newGrade)` improve the system?'

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

Activity 04

• Problem-Based Learning
• 25 min · Individual

Individual: Refactor Real-World Snippet

Students receive a non-encapsulated e-commerce Cart class and add private totals with validated addItem/removeItem. Test with edge cases like over-removal, then write a short log of changes made.

Why is it important to hide the internal implementation details of a class?

Facilitation Tip

For Refactor Real-World Snippet, display a before-and-after refactoring on the board so students see the value of encapsulation in practice.

What to look for

Present students with short code snippets. Ask them to identify which members are public and which are private, and to explain why a particular access attempt would result in an error. For example: 'In this `Car` class, why can we directly change `car.speed` but not `car.engineStatus'?

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

A few notes on teaching this unit

Experienced teachers approach encapsulation by making the invisible visible. Start with a broken class and let students trip over direct access errors, then guide them to fix it with access modifiers. Avoid starting with theory; instead, let students discover the need for encapsulation through frustration. Research shows this discovery method builds deeper understanding than lectures alone. Use real-world analogies, like a bank vault, to make the concept relatable.

Successful learning looks like students confidently explaining why certain data should be private, writing getters and setters with validation, and debugging encapsulation issues without prompting. They should also describe how changes to internal details do not affect external code, showing an understanding of maintenance benefits.

---

Watch Out for These Misconceptions

• During Pair Programming: Broken vs Protected Class, watch for students assuming private fields make data unusable entirely.

  Have the pair attempt to access private fields directly, observe the compile error, then implement getters and setters with validation to demonstrate controlled access.

• During Secure User Profile Design, watch for students treating encapsulation as purely for security.

  Ask groups to explain how changing a validation rule in a setter (like age range) would affect the class without altering public methods, highlighting maintenance benefits.

• During Encapsulation Debug Challenge, watch for students believing public access is always simpler and faster.

  After they fix a broken class, ask them to change the internal logic (e.g., from int to double for balance) and note how public methods remain unchanged, proving encapsulation prevents rework.

---

Methods used in this brief

• Problem-Based Learning