Computer Science · 11th Grade

Active learning ideas

Introduction to OOP Concepts

Active learning works for this topic because OOP concepts like encapsulation and inheritance are abstract until students physically build and modify code. Students need to see how classes bundle data with behavior, not just hear definitions, so hands-on design and comparison activities make these ideas stick.

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

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

Activity 01

• Concept Mapping
• 30 min · Pairs

Pair Programming: Design a Bank Account Class

Pairs define a BankAccount class with attributes like balance and methods like deposit() and withdraw(). They create instances, test transactions, and discuss encapsulation by hiding balance changes. Pairs share one success and one error with the class.

Explain the fundamental concepts of objects, classes, and instances.

Facilitation Tip

During Pair Programming, circulate and ask each pair to explain why they chose a particular attribute or method for their Bank Account class before coding.

What to look for

Present students with a short code snippet or pseudocode. Ask them to identify: 1) Which parts represent a class definition, 2) Which parts represent object instantiation, and 3) What are the attributes and methods of the objects created?

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 02

• Concept Mapping
• 45 min · Small Groups

Small Groups: Procedural vs OOP Rewrite

Groups receive procedural code for a library system and rewrite it using classes for Book and Library. They time both versions for adding books and compare readability. Groups present findings on a shared board.

Compare procedural programming with object-oriented programming paradigms.

Facilitation Tip

When Small Groups rewrite procedural code into OOP, provide a checklist of OOP features to identify, like classes, inheritance, and encapsulation, to guide their comparison.

What to look for

Facilitate a class discussion using the prompt: 'Imagine you are building a system to manage library books. Would you use procedural or object-oriented programming? Justify your choice by explaining how you would represent books and the actions they can perform using OOP concepts like classes and objects.'

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 03

• Concept Mapping
• 40 min · Whole Class

Whole Class: UML Diagramming Challenge

Project a scenario like a zoo management system. Class brainstorms classes, attributes, and relationships, then draws UML diagrams on chart paper. Vote on the clearest diagram and code a snippet from it.

Justify the advantages of using OOP for complex software development.

Facilitation Tip

For the UML Diagramming Challenge, require each group to present their diagram and justify one design choice to the class before moving on.

What to look for

Provide students with a scenario, e.g., 'Modeling a simple calculator.' Ask them to write down: 1) The name of a class they would create, 2) Two attributes for that class, and 3) Two methods (behaviors) for that class.

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

Activity 04

• Concept Mapping
• 25 min · Individual

Individual: Instance Exploration

Students code a Shape class hierarchy with Circle and Rectangle subclasses, each with area() methods. They instantiate multiple objects, call methods, and log polymorphism results in a table.

Explain the fundamental concepts of objects, classes, and instances.

What to look for

Present students with a short code snippet or pseudocode. Ask them to identify: 1) Which parts represent a class definition, 2) Which parts represent object instantiation, and 3) What are the attributes and methods of the objects created?

• Understand
• Analyze
• Create
• Self-Awareness
• Self-Management

A few notes on teaching this unit

Teachers should start with concrete examples students recognize, like bank accounts or library books, to ground abstract concepts in familiar contexts. Avoid rushing to definitions—instead, let students discover encapsulation by seeing how methods protect data. Research shows students grasp inheritance best when they compare class hierarchies they design themselves, not when presented with diagrams alone.

Successful learning looks like students confidently distinguishing classes from objects, explaining how encapsulation hides data, and justifying when to use OOP versus procedural code. They should also critique designs, debug class structures, and articulate tradeoffs between paradigms.

---

Watch Out for These Misconceptions

• During Pair Programming: Design a Bank Account Class, watch for students treating classes as simple data containers without methods.

  Ask pairs to write down at least three actions an account should perform, like deposit or withdraw, and include these as methods before coding any attributes.

• During Small Groups: Procedural vs OOP Rewrite, watch for students copying procedural code directly into a class without changing its structure.

  Have groups highlight where global variables become attributes and where functions become methods, then justify each change to the class.

• During Whole Class: UML Diagramming Challenge, watch for students drawing identical objects for a class, implying shared state.

  Ask students to label two objects with different attribute values on their diagrams and explain why each maintains its own state.

---

Methods used in this brief

• Concept Mapping