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.

• 11th Grade
• Computer Science
• 4 activities
• 25 min–45 min

Learning Objectives

1. Compare and contrast the core concepts of classes, objects, and instances in OOP with procedural programming constructs.
2. Analyze the benefits of encapsulation, inheritance, and polymorphism for managing software complexity.
3. Design a simple class diagram to model real-world entities for a given problem.
4. Evaluate the suitability of OOP versus procedural programming for specific software development scenarios.
5. Create a basic program demonstrating the instantiation and interaction of multiple objects.

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.

Prepare & details

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.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

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

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.

Prepare & details

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.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

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

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.

Prepare & details

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.

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

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

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.

Prepare & details

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

Setup: Tables with large paper, or wall space

Materials: Concept cards or sticky notes, Large paper, Markers, Example concept map

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

Teaching This Topic

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.

What to Expect

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

Common Misconception

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

What to Teach Instead

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.

Common Misconception

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

What to Teach Instead

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

Common Misconception

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

What to Teach Instead

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

Assessment Ideas

Quick Check

After Pair Programming: Design a Bank Account Class, present students with a short pseudocode snippet and ask them to identify the class definition, an object instantiation, and the attributes and methods of the objects created.

Discussion Prompt

After Small Groups: Procedural vs OOP Rewrite, 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.'

Exit Ticket

After Whole Class: UML Diagramming Challenge, provide students with a scenario like '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.

Extensions & Scaffolding

• Challenge: Ask students to extend their Bank Account class to include overdraft protection and interest calculation, then test edge cases like negative balances.
• Scaffolding: For students struggling with UML, provide partially completed diagrams with missing attributes or methods and have them fill in gaps before designing their own.
• Deeper exploration: Introduce composition by asking students to model a Bank that contains multiple Account objects, then discuss how this differs from inheritance.

Key Vocabulary

Class	A blueprint or template for creating objects. It defines the properties (attributes) and behaviors (methods) that all objects of that type will have.
Object	An instance of a class. It is a concrete entity created from the class blueprint, possessing its own state (values for attributes) and behavior.
Instance	A specific realization of a class. When you create an object from a class, you are creating an instance of that class.
Encapsulation	The bundling of data (attributes) and methods that operate on the data within a single unit (a class). It restricts direct access to some of an object's components.
Inheritance	A mechanism where a new class (subclass or derived class) inherits properties and behaviors from an existing class (superclass or base class).
Polymorphism	The ability of an object to take on many forms. In OOP, it often refers to the ability of different objects to respond to the same method call in their own specific ways.