Summary  
This chapter demonstrates object composition in OOP by having a main class contain full instances of other classes (e.g., Weapon, Armor, Enemy), enabling modular design and dynamic interactions through equipping and using different components.  

General domain of usage  
Game development (RPG systems)

The great way to show composition is to build an RPG warrior system step by step. Starting from simple equipment classes and ending with a fully interactive warrior, each component contributes to a dynamic and flexible design.

Even if certain classes like **Armor** or **Shield** do not participate in calculations immediately, it is useful to create them early. They complete the warrior’s gear, improve clarity, and prepare the system for future extensions.

Note

The system begins with the **Weapon** class. It defines three attributes—**name**, **attack**, and **weapon type**—and includes a string method that produces readable output such as *“Broadsword, Attack 20”*.
The next step introduces **Armor**, **Helmet**, and **Shield** classes. Each has a **name**, a **defense value**, and a **material type**, also supported by string methods.

The **Enemy** class adds interaction. With a single attribute (**HP**) and a method `take_damage()`, it reacts to attacks by reducing health, printing the amount lost, and announcing defeat when health reaches zero.

The centerpiece is the **Warrior** class. Instead of raw stats, it holds full instances of other classes: armor, helmet, and shield are assigned at creation, while the weapon slot starts empty.
The warrior can:

* **equip a weapon** dynamically using `equip_weapon()`,
* **attack an enemy** with the weapon’s attack value,
* **display status** by pulling information from the composed gear.

This RPG warrior system illustrates how multiple objects interact to create dynamic behavior. Weapons define damage, gear completes the warrior’s identity, and enemies provide feedback through combat. The result is a modular structure where different configurations lead to different outcomes, making the system both reusable and adaptable.

Which statement best illustrates the role of composition in the RPG warrior system?

Erlernen Sie, wie man saubere, sichere und skalierbare Anwendungen mit objektorientierter Programmierung in Python entwickelt. Behandelt werden die Grundlagen von Klassen und Objekten sowie fortgeschrittene Konzepte wie Vererbung, Komposition, Polymorphismus und Kapselung. Mit klaren Erklärungen und praxisnahen Beispielen entwickeln Sie die Fähigkeit, Python-Programme zu entwerfen, die leistungsfähig, wartbar und für den realen Einsatz bereit sind.

Erlernen Sie die grundlegenden Bausteine der objektorientierten Programmierung in Python. Dieser Abschnitt behandelt Klassen, Objekte, Methoden und Variablen und vermittelt eine solide Grundlage, um zu verstehen, wie OOP Code organisiert und strukturiert.

Erkunden Sie, wie Klassen Funktionalitäten teilen und erweitern können. Sie lernen verschiedene Vererbungsmuster kennen, von einfachen Hierarchien bis hin zu Mehrfachvererbung und abstrakten Klassen, und erfahren, wie diese die Wiederverwendbarkeit und Skalierbarkeit von Code ermöglichen.

Erfahren Sie, wie Sie flexible Systeme durch die Kombination von Objekten erstellen. Anstatt sich ausschließlich auf Vererbung zu verlassen, zeigt Ihnen die Komposition, wie Sie Verhaltensweisen modular und anpassungsfähig zusammenstellen können.

Verstehen, wie verschiedene Objekte eine gemeinsame Schnittstelle teilen können, während sie sich unterschiedlich verhalten. Dieser Abschnitt zeigt, wie Methodenüberschreibung, Schnittstellen und Protokolle Ihren Code dynamischer und wiederverwendbarer machen.

Erfahren Sie, wie interne Daten geschützt und der Zugriff auf Klassenattribute kontrolliert werden kann. Sie werden private Attribute, Getter und Setter sowie Techniken zur Datenverbergung kennenlernen, die Ihre Klassen sicher und wartbar halten.

Composition Implementation