Lesson Module · Detail

Own Classes (The Mini-Linus)

They introduce the class concept as a blueprint and link method definitions to concrete actions of an instance. Didactically, modeling behavior (methods) and their systematic application in a navigation-oriented task are in the center.

Time 10 minutes

Format rpgDungeon

Language Python 2 (CE)

Tasks 1

Introduction (Original excerpt)

Didactic classification

Subjective goal setting

The building block introduces the concept of a class as a blueprint and makes it visible how an abstract model (class) is transformed into a usable object (instance). The focus is on structuring behavior through methods that encapsulate specific movement directions. Learners work with a helper method for turning and derive further methods systematically from it. The connection between model and implementation is operationalized by direct method calls at an instance (e.g. robot). This makes it clear how design ideas (robot capabilities) are converted into concrete, reusable program interfaces.

Competence development

• Describing classes as blueprints and distinguishing them from objects/instances.
• Identifying methods as functions bound to a class and naming them accordingly.
• Creating an instance and formulating method calls in correct point notation.
• Structuring recurring action sequences through method formation (abstraction).
• Using helper methods to avoid duplicating repeated logic (e.g. orientation).
• Planning step sequences and implementing them as a coordinated command sequence to achieve a goal.
• Locating errors in method definition or usage (e.g. missing methods) and correcting them specifically.

Didactic added value in the classroom

• Clear progression from “functions” to “classes/objects” as the next step in structuring.
• Manageable task assignment that focuses a central OOP concept on a concrete application case.
• Promoting systematic thinking by separating helper logic (rotation) and action logic (movement).
• Transparent goal orientation through a clear target point and verifiable step-by-step procedures.
• Building on differentiation through extensions (e.g., additional movement or control logic), without assuming additional topics.

Flow of the lesson unit

Work assignment (excerpt)

Example (excerpt)

The fragment is didactically relevant because it demonstrates the reuse of a helper method and encapsulation of an action as a method in the class.

1
2
3
4
5
6
7
8

class Roboter:
    def _drehe_zu(self, ziel):
        while richtung() != ziel:
            rechts_drehen()

    def links(self):
        self._drehe_zu("left")
        bewegen()

Hints for teaching practice

• Lesson planning: Plan a short introduction (class, method, instance) and then the implementation phase with a focus on two missing methods.
• Differentiation possibilities: Offer extensions through additional methods (e.g. consistent addition of further directions) or alternative route strategies.
• Result security: Allow the method signatures and the idea “blueprint → instance → method call” to be recorded at a jointly created table image.
• Possible extensions: Discuss how recurring processes can be reduced through helper methods and what advantages this has for maintainability and understandability.
• Link to further topics: Use the building block as a transition to object state/attributes or systematic testability of methods (without new platform assumptions).

The clear task structure supports rapid lesson organization and facilitates result security through defined methods and their use. Differentiation is possible through additional movement logic or alternative step sequences.

Request access to the demo and test the building block in your own course context to accompany the transition from functions to classes specifically.