Klassen und Objekte

In L1 hast du gesehen warum es OOP gibt. Jetzt geht's um die zwei zentralen Begriffe, die du in jeder OOP-Lektion wieder antreffen wirst: Klasse und Objekt. Sie werden oft synonym gebraucht und doch beschreiben sie etwas Verschiedenes. Wer den Unterschied klar im Kopf hat, hat 50% der OOP-Theorie schon verstanden.

Wir bauen das Mentalmodell mit konkreten Analogien auf, schauen uns die Lebenszyklen an, vergleichen die Syntax in Python und Java, und enden mit den Begriffen die in Klausuren wichtig sind: Instanziierung, Referenz, Identität.

1) Die Schlüsselanalogie: Bauplan und Bauwerk

Stell dir einen Architekten-Bauplan für ein Einfamilienhaus vor. Der Bauplan ist nicht das Haus – er beschreibt nur, wie das Haus aussehen soll. Mit einem Bauplan kannst du beliebig viele tatsächliche Häuser bauen. Jedes davon hat die gleiche Grundstruktur (4 Wände, 1 Dach, 1 Tür) – aber konkrete eigene Werte: Farbe der Wände, Hausnummer, Bewohner.

Bauplan = Klasse: abstrakte Beschreibung, existiert nur als Konzept
Tatsächliches Haus = Objekt: konkrete Instanz, existiert real im Speicher

Eine andere beliebte Analogie: Ausstecher und Plätzchen. Der Ausstecher ist die Klasse – die Form. Jedes Plätzchen ist ein Objekt – eine Instanz dieser Form. Aus einem Ausstecher entstehen viele Plätzchen, aber jedes ist ein eigenes physisches Objekt:

Ausstecher (Klasse) → Plätzchen (Objekte)

⭐

Klasse Stern

→

Drei Plätzchen, alle gleicher Form – aber drei unterschiedliche Objekte. Du kannst eines verzieren, eines essen, eines wegschmeißen, ohne dass die anderen oder der Ausstecher betroffen wären. Genauso bei Objekten: du veränderst stern_1.farbe und stern_2 bleibt unberührt.

Die Analogie hilft auch bei der Frage wann existiert was?: Die Klasse (Ausstecher) wird einmal definiert. Objekte (Plätzchen) entstehen zur Laufzeit, wenn du sie „herstellst". Ohne Ausstecher keine Sterne – ohne Klasse keine Instanzen.

2) Klassen-Definition vs. Objekt-Erzeugung

Schauen wir den Code-Unterschied genauer an. Eine Klassen-Definition sagt nur wie etwas auszusehen hat – sie erzeugt selbst nichts. Eine Instanziierung erschafft tatsächlich ein Objekt im Speicher:

klasse_vs_objekt.pyPython

1# Klassen-DEFINITION (Bauplan)
2class Hund:
3    def __init__(self, name, alter):
4        self.name = name
5        self.alter = alter
6
7    def bellen(self):
8        print(f"{self.name}: Wuff!")
9
10# INSTANZIIERUNG (Objekt erschaffen)
11rex = Hund("Rex", 5)
12bella = Hund("Bella", 3)
13
14rex.bellen()    # Rex: Wuff!
15bella.bellen()  # Bella: Wuff!

Zeilen 2-8: Klassen-Definition. Bis hier ist noch kein Hund erschaffen. Zeile 11: Hund("Rex", 5) ist die Instanziierung – jetzt entsteht ein Objekt namens Rex. Zeile 12: ein zweites Objekt entsteht. Beide haben unabhängige Daten, aber teilen sich den Code der Methoden.

3) Vergleich: Java, Python, JavaScript

Die Syntax variiert, das Konzept bleibt gleich. Wer eine Sprache versteht, versteht auch die anderen mit minimalem Aufwand:

Hund.javaJava

1public class Hund {
2    private String name;
3    private int alter;
4
5    public Hund(String name, int alter) {
6        this.name = name;
7        this.alter = alter;
8    }
9
10    public void bellen() {
11        System.out.println(name + ": Wuff!");
12    }
13}
14
15Hund rex = new Hund("Rex", 5);

hund.jsJavaScript (ES6+)

1class Hund {
2    constructor(name, alter) {
3        this.name = name;
4        this.alter = alter;
5    }
6
7    bellen() {
8        console.log(`${this.name}: Wuff!`);
9    }
10}
11
12const rex = new Hund("Rex", 5);

Drei Sprachen, dasselbe Konzept. Java verlangt new, Python nicht, JavaScript schon. Python nutzt self, Java und JS this – beides bezeichnet dasselbe: das aktuelle Objekt. Java verlangt Typdeklarationen, Python ist dynamisch typisiert.

4) Klassen-Anatomie: Blueprint visualisiert

Schau dir eine Klasse als Bauplan an, mit Attributen (Daten) und Methoden (Verhalten). Aus dem einen Bauplan entstehen mehrere Instanzen – jede mit eigenen Daten:

Klasse als Blueprint, Objekte als Instanzen

Bauplan

Hund

Attribute

• name : String

• alter : int

• rasse : String

Methoden

→ bellen()

→ apportieren()

→ get_alter()

⟹ instanziieren

rex : Hund

name = "Rex"

alter = 5

rasse = "Schäfer"

bella : Hund

name = "Bella"

alter = 3

rasse = "Labrador"

max : Hund

name = "Max"

alter = 8

rasse = "Dackel"

Wichtig zur Trennung: Methoden werden einmal in der Klasse definiert und von allen Instanzen geteilt. Aber die Attribut-Werte sind pro Instanz unterschiedlich – jeder Hund hat seinen eigenen Speicher für name, alter, rasse. Im Speicher: 1 Klassen-Objekt + N Instanz-Objekte, wobei jedes Instanz-Objekt nur die Attribut-Werte hält und intern eine Referenz auf seine Klasse.

In Klausuren wird oft gefragt: „Was wird im Speicher gehalten, wenn ich 1000 Hund-Objekte habe?" Antwort: 1× der Methoden-Code (in der Klasse) + 1000× die Attribut-Werte. Methoden werden NICHT pro Instanz dupliziert – das ist eine Performance-Optimierung der OOP-Laufzeitumgebung.

5) Lebenszyklus eines Objekts

Ein Objekt lebt nicht ewig. Es durchläuft mehrere Phasen, die du als Entwickler beeinflussen kannst:

Lebenszyklus eines Objekts

Allokation: Speicher für das Objekt wird reserviert. In Java/C# auf dem Heap. In Python ebenfalls dynamisch.

Initialisierung (Konstruktor): der Konstruktor läuft – setzt Anfangswerte für die Attribute. In Python __init__, in Java derselbe Name wie die Klasse. Mehr in L3.

Verwendung: Methoden werden aufgerufen, Attribute gelesen und geschrieben. Der eigentliche Lebensabschnitt – kann von Millisekunden bis Stunden dauern.

Unreferenzierung: keine Variable zeigt mehr auf das Objekt. In Python: rex = None oder Variable verlässt den Scope. Das Objekt existiert noch, ist aber „unerreichbar".

Garbage Collection: die Sprach-Laufzeit erkennt das Objekt als ungenutzt und gibt den Speicher frei. In Python via Reference-Counting + zyklischer GC, in Java über die JVM. In K46 L4 kannst du Memory-Themen vertiefen.

Optional: Destruktor: manche Sprachen lassen vor der Speicher-Freigabe einen „Destruktor" laufen (Python __del__, C++ Destruktoren). Selten genutzt, oft heikel in Garbage-collected Sprachen.

Java hat keine expliziten Destruktoren mehr – es gibt nur finalize(), das aber seit Java 9 deprecated ist. Stattdessen nutzt man try-with-resources oder das AutoCloseable-Interface für Ressourcen-Bereinigung. In Python ist __del__ möglich, aber unzuverlässig. Best Practice: with-Statement nutzen für Files, Datenbankverbindungen usw.

6) Identität, Gleichheit, Referenz

Ein subtil-wichtiges Thema das in fast jeder Klausur drankommt: der Unterschied zwischen Identität und Gleichheit. Klingt philosophisch, ist aber Code-relevant.

Drei verschiedene Begriffe

Referenz

Eine Variable zeigt auf ein Objekt. Du kannst mehrere Variablen auf dasselbe Objekt zeigen lassen – dann sind es Aliase.

Identität (==)

Sind das genau dasselbe Objekt im Speicher? Java ==, Python is. Vergleicht die Speicheradresse.

Gleichheit (equals)

Haben die Objekte den gleichen Wert/Inhalt? Java .equals(), Python ==. Kann selbst definiert werden.

identitaet.pyPython

1hund1 = Hund("Rex", 5)
2hund2 = Hund("Rex", 5)  # gleiche Werte, anderes Objekt!
3hund3 = hund1                # Alias - selbe Referenz
4
5hund1 is hund2   # False (zwei verschiedene Objekte)
6hund1 is hund3   # True  (zeigen aufs gleiche)
7hund1 == hund2   # False! (Python: == ohne __eq__ ist wie is)

Dieses Verhalten ist auch in K46 L10 Bug-Hunt #3 als typischer Java-Anfänger-Fehler aufgetaucht: str1 == str2 mit Strings gibt oft false zurück, weil == in Java die Identität prüft. Richtig wäre str1.equals(str2).

7) Eingebaute Klassen sind auch Klassen

Eine wichtige Erkenntnis für Anfänger: auch eingebaute Typen sind Klassen. String in Java, str in Python, Array in JavaScript – alle Klassen. Du arbeitest mit ihren Objekten ständig, ohne sie als „OOP" wahrzunehmen:

builtin.pyPython

1name = "Anna"           # Objekt vom Typ str
2name.upper()             # Methodenaufruf!
3name.replace("A", "X")   # Methodenaufruf!
4
5numbers = [1, 2, 3]      # Objekt vom Typ list
6numbers.append(4)         # Methode der Klasse list
7type(numbers)            # <class 'list'>

Wenn du Strings, Listen, Dictionaries nutzt und ihre Methoden aufrufst – machst du bereits OOP. Du hast es nur nicht gemerkt. Genau diese Mächtigkeit ist der Grund, warum OOP-Sprachen so weit verbreitet sind: das Konzept ist überall.

8) Häufige Anfänger-Verwirrungen

Wenn du am Anfang strugglest, du bist nicht allein. Hier die typischen Stolperfallen die alle Lernenden treffen:

Klasse und Objekt verwechseln: Hund ist die Klasse, rex ein Objekt davon. Niemals Hund.bellen() ohne Instanz aufrufen – außer es ist eine statische Methode (Thema L3).
Self/this vergessen: in Python ist self der erste Parameter jeder Methode. Vergisst du es, bekommst du verwirrende Fehler. Java/JS fügen this implizit hinzu.
Konstruktor vs. Klassen-Definition: die Klasse wird einmal definiert (Code-Datei). Der Konstruktor läuft jedes Mal wenn ein Objekt erzeugt wird.
Referenz vs. Kopie: in Python und Java enthalten Variablen Referenzen, keine Werte. a = b macht keinen Klon!
Daten zwischen Instanzen vermischen: jede Instanz hat ihre eigenen Attribute. Wenn du nicht aufpasst, definierst du aus Versehen Klassen-Attribute (für alle gleich) statt Instanz-Attribute – kommt in L3.

9) Wann eine Klasse, wann nicht?

Junge Entwickler neigen dazu, für alles Klassen zu erfinden. Erfahrenere wissen: nicht jedes Problem braucht OOP. Gute Indikatoren für eine eigene Klasse:

Ja, Klasse:

Du modellierst eine Sache der echten Welt (Kunde, Bestellung, Auto)
Du hast mehrere Instanzen mit unterschiedlichen Werten gleicher Struktur
Daten und Logik gehören eng zusammen
Du erwartest spätere Erweiterungen oder Sub-Typen

Eher nicht:

Nur ein einzelnes Datenpaket → tuple oder dict reicht
Reine Berechnungs-Funktion → einfach eine Funktion
Du hast eine Klasse mit nur einer Methode → das ist meist eine Funktion in Verkleidung
Zwei Datenfelder → vielleicht ein Tupel oder Named Tuple

10) Klassen sind ein Namensraum

Eine oft übersehene Funktion von Klassen: sie sind ein Namensraum. Methoden in verschiedenen Klassen können denselben Namen haben, ohne dass es Konflikte gibt:

namespace.pyPython

1class Datei:
2    def oeffnen(self): ...
3
4class Fenster:
5    def oeffnen(self): ...
6
7f = Datei()
8w = Fenster()
9f.oeffnen()  # Datei-Methode
10w.oeffnen()  # Fenster-Methode - kein Konflikt!

Im prozeduralen Code müsstest du sie datei_oeffnen() und fenster_oeffnen() nennen, um Verwechslung zu vermeiden. OOP gibt dir das geschenkt. Polymorphismus (kommende L6) baut sogar gezielt auf diesem Konzept auf: gleicher Methodenname, verschiedene Implementierung pro Klasse.

Zusammenfassung

Eine Klasse ist ein Bauplan, ein Objekt eine konkrete Instanz davon. Aus einer Klasse entstehen beliebig viele Objekte mit eigenen Attribut-Werten, aber geteiltem Methoden-Code. Instanziierung mit new ClassName(...) in Java/JS, ohne new in Python. Identität (selbes Objekt) ist nicht Gleichheit (gleicher Wert). Auch eingebaute Typen wie String und list sind Klassen – OOP ist überall. Nutze Klassen wenn du echte Entitäten modellierst, nicht für jede triviale Berechnung.