Computer Science · 11th Grade · Object-Oriented Programming · Weeks 19-27

Classes and Objects

Defining custom data types (classes) and creating instances (objects) with attributes and behaviors.

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

About This Topic

Classes serve as blueprints for custom data types in object-oriented programming, allowing students to define attributes for data storage and methods for behaviors. Objects are instances of these classes, each with their own unique state. At the 11th grade level, students construct class definitions, create objects, and model real-world entities like vehicles or bank accounts, addressing key questions on differentiation and design.

This topic anchors the Object-Oriented Programming unit, linking procedural coding skills to modular, reusable code structures. Students practice encapsulation by bundling data and operations, preparing for inheritance and polymorphism. These concepts foster computational thinking, as modeling complex systems mirrors software engineering practices in industry.

Active learning shines here because abstract syntax gains meaning through iterative coding and testing. When students collaborate on class designs for shared projects or debug object interactions in pairs, they experience how poor attribute choices break functionality, making concepts tangible and errors teachable moments. Hands-on practice builds confidence in designing robust classes.

Key Questions

1. Construct a class definition with appropriate attributes and methods.
2. Differentiate between a class and an object, and how they relate.
3. Design a class to model a real-world entity, considering its properties and actions.

Learning Objectives

• Design a Python class to model a real-world entity, including appropriate attributes and methods.
• Compare and contrast the concepts of a class and an object, explaining their relationship.
• Construct a class definition in Python, specifying data types for attributes and return types for methods.
• Analyze the encapsulation of data and behavior within a class definition.
• Create multiple objects from a single class, demonstrating how each object maintains its own state.

Before You Start

Basic Data Types and Variables

Why: Students need to understand how to declare and assign values to variables before they can define attributes within a class.

Functions and Control Flow

Why: Students must be familiar with defining and calling functions to understand how methods work within a class.

Key Vocabulary

Class	A blueprint or template for creating objects, defining the attributes (data) and methods (behaviors) that all objects of that type will have.
Object	An instance of a class, representing a specific entity with its own unique state (values for its attributes) and access to the class's methods.
Attribute	A variable that belongs to an object, storing the data or state of that object. Also known as a field or member variable.
Method	A function defined within a class that describes the behaviors or actions an object can perform.
Instantiation	The process of creating an object from a class definition.

Watch Out for These Misconceptions

Common Misconception

A class is the same as an object.

What to Teach Instead

Classes define the template, while objects are specific instances with independent states. Active pair programming helps, as partners create multiple objects from one class and observe distinct behaviors, clarifying the blueprint-instance relationship through direct comparison.

Common Misconception

All objects from the same class share the same data.

What to Teach Instead

Each object maintains its own attribute values. Small group simulations, like racing vehicle objects, reveal how one object's fuel depletion does not affect others, using collaborative testing to dispel this via observable differences.

Common Misconception

Methods only access class-level data, not object attributes.

What to Teach Instead

Methods operate on the instance's data using 'self' or 'this'. Whole-class live coding exposes this when method calls on different objects yield unique results, with student-led examples reinforcing instance-specific execution.

Active Learning Ideas

Pair Programming: Bank Account Class

Pairs define a BankAccount class with attributes like balance and owner, plus methods for deposit and withdraw. They create two objects, simulate transactions, and test edge cases like overdrafts. Pairs then swap code to identify and fix bugs.

45 min·Pairs

Small Groups: Vehicle Fleet Simulator

Groups design a Vehicle class with attributes such as speed and fuel, and methods like accelerate and refuel. Each member instantiates multiple objects into a fleet list, simulates a race, and logs results. Groups present one buggy scenario for class debugging.

50 min·Small Groups

Whole Class: Real-World Entity Brainstorm

As a class, brainstorm a Student class based on school context, listing attributes and methods on the board. Code the class together, projecting the editor. Students volunteer objects and call methods live, discussing outputs.

30 min·Whole Class

Individual: Object Factory Challenge

Individuals extend a base Shape class with Circle and Rectangle subclasses, adding area methods. Create an array of objects, compute total area, and visualize with simple prints. Submit code for peer review.

35 min·Individual

Real-World Connections

• Software engineers at companies like Google use classes to model complex systems, such as user accounts in a social media application or inventory items in an e-commerce platform.
• Game developers create classes for characters, enemies, and items in video games. For example, a 'Player' class might have attributes for health, score, and inventory, and methods for moving or attacking.

Assessment Ideas

Quick Check

Provide students with a simple class definition (e.g., a 'Dog' class with 'name' and 'breed' attributes). Ask them to write the Python code to create two different 'Dog' objects, each with unique names and breeds, and then print one attribute from each object.

Discussion Prompt

Pose the question: 'Imagine you are designing a class for a 'Book'. What attributes would be essential to include? What methods would a 'Book' object need to perform? Discuss with a partner and list your ideas.'

Exit Ticket

On an index card, have students write down one difference between a class and an object. Then, ask them to provide a real-world analogy for a class and its corresponding object (e.g., cookie cutter and cookie).

Frequently Asked Questions

How do you explain classes versus objects to 11th graders?

Start with a blueprint analogy: a class is the car design, objects are built cars with unique colors and mileage. Code a simple Pet class live, create two Pet objects, and modify one's name to show independence. This visual, hands-on demo, followed by student replication, cements the distinction in 10 minutes.

What activities teach class design for real-world modeling?

Use pair programming for entities like LibraryBook, focusing on attributes (title, dueDate) and methods (checkOut, return). Groups iterate designs based on use cases, test with objects, and refine. This builds skills in identifying properties and actions, aligning with CSTA standards through practical application.

How can active learning help students master classes and objects?

Active approaches like collaborative coding challenges make syntax and concepts concrete. Pairs designing classes for games or simulations test methods immediately, revealing errors in real-time. Group critiques of object interactions develop debugging skills and deeper understanding, far beyond passive lectures, as students own the code and outcomes.

Common errors in defining class attributes and methods?

Errors include forgetting instance variables or static confusion. Guide with templates, then let small groups code and share failures, like non-updating balances. Corrections via peer review emphasize 'self' usage, turning mistakes into learning through immediate, shared feedback loops.