Attribute, Methoden, Konstruktor

In L2 hast du Klassen und Objekte als Konzept kennengelernt. Jetzt schauen wir das Innenleben einer Klasse an. Eine Klasse besteht aus drei Bausteinen: Attributen (was sie weiß), Methoden (was sie kann) und einem Konstruktor (wie sie geboren wird). Wer diese drei beherrscht, kann jede Klasse lesen.

Diese Lektion ist praxisorientiert – wir gehen jeden Baustein konkret durch, mit Code-Beispielen aus Java und Python, und schauen uns die Unterschiede zwischen Klassen- und Instanzattributen an, was eine statische Methode ist, und wann man welchen Konstruktor schreibt. Klausur-relevant!

1) Die drei Bestandteile im Überblick

Egal welche OOP-Sprache: jede Klasse ist nach derselben Logik aufgebaut. Schau dir die Anatomie an – klick die einzelnen Elemente an, um zu sehen welche Rolle sie spielen:

Anatomie einer Klasse – klick die Elemente

class Auto Klasse

Klassen-Attribute (für alle gleich)

A anzahl_raeder = 4 int

Instanz-Attribute (pro Objekt)

A marke String

A kilometerstand int

Konstruktor (Initialisierung)

C __init__(marke, km) setzt Anfangswerte

Methoden (Verhalten)

M fahren(km) verändert Zustand

M info() → String

S @staticmethod fabrik() braucht kein self

Klick eines der Elemente links für eine Erklärung.

Die drei Hauptkategorien Attribut · Konstruktor · Methode sind in allen OOP-Sprachen ähnlich strukturiert. Manche Sprachen erlauben zusätzliche Elemente wie statische Methoden, Klassenmethoden, Properties, Getter/Setter – aber das ist Verzierung. Der harte Kern ist diese Trias.

2) Attribute: was die Klasse weiß

Attribute (auch Felder in Java, Properties in JavaScript, Member-Variablen allgemein) sind die Daten eines Objekts. Sie speichern den Zustand zwischen Methodenaufrufen. Eine wichtige Unterscheidung:

Instanz-Attribute: existieren pro Objekt getrennt. Anna's Hund hat einen anderen Namen als Bobs Hund.
Klassen-Attribute: gehören zur Klasse selbst, geteilt von allen Instanzen. Z.B. die Spezies aller Hunde ist „Canis familiaris".

attribute.pyPython

1class Hund:
2    # KLASSEN-Attribut: für alle Hunde gleich
3    spezies = "Canis familiaris"
4
5    def __init__(self, name):
6        # INSTANZ-Attribut: pro Hund anders
7        self.name = name
8
9rex = Hund("Rex")
10bella = Hund("Bella")
11
12rex.name       # "Rex"
13bella.name     # "Bella"
14rex.spezies    # "Canis familiaris"  (vom Klassen-Attr)
15bella.spezies  # "Canis familiaris"  (gleicher Wert)

Anfänger-Falle: in Python ist es leicht versehentlich ein Klassen-Attribut zu definieren statt eines Instanz-Attributs. Wenn du Listen oder andere veränderliche Objekte als Klassen-Attribute setzt, teilen sich alle Instanzen dieselbe Liste – und Änderungen wirken sich global aus. Das ist fast immer ein Bug. Faustregel: Listen/Dicts immer im Konstruktor mit self. erzeugen.

3) Methoden: was die Klasse kann

Methoden sind Funktionen, die zu einer Klasse gehören. Sie operieren typischerweise auf den Attributen des Objekts. In Python und JavaScript wird das aktuelle Objekt explizit als erster Parameter self bzw. implizit als this übergeben:

Methodenaufruf: das Objekt wird selbst übergeben

rex.bellen()

bellen(self=rex)

Wenn du rex.bellen() schreibst, übersetzt Python das intern zu Hund.bellen(rex). Das Objekt rex wird als self-Parameter an die Methode übergeben. Deshalb hat jede Methoden-Definition self als ersten Parameter – sonst wüsste sie nicht, welches Objekt sie behandeln soll.

In Java und C# passiert das implizit: du schreibst this, aber es ist nicht in der Parameterliste sichtbar. Python ist da expliziter und ehrlicher – manche Entwickler lieben das, andere finden's umständlich. Geschmackssache, das Konzept ist gleich.

Methoden werden in vier Hauptkategorien eingeteilt:

Kategorie	Zweck	Beispiel
Getter	Wert eines Attributs lesen	`get_name()`
Setter	Wert eines Attributs schreiben (oft mit Validierung)	`set_name(neuer)`
Modifier	Zustand verändern	`einzahlen(betrag)`
Query	Berechnung ohne Veränderung	`ist_minderjaehrig()`

Bei modernen Sprachen wird die Unterscheidung Getter/Setter durch Properties ersetzt – in Python mit @property, in C# mit Auto-Properties. Dazu mehr in L4.

4) Konstruktor: der Geburtshelfer

Der Konstruktor ist eine spezielle Methode, die automatisch beim Erzeugen eines neuen Objekts aufgerufen wird. Sein Job: Anfangswerte setzen. Jede Sprache nennt ihn anders:

Python: def __init__(self, ...)
Java: gleichnamige Methode wie die Klasse, ohne Return-Type: public Hund(...)
JavaScript: constructor(...)
C++: gleichnamige Methode wie die Klasse
C#: wie Java

Hund.javaJava

1public class Hund {
2    private String name;
3    private int alter;
4
5    // Konstruktor: gleicher Name wie Klasse
6    public Hund(String name, int alter) {
7        this.name = name;
8        this.alter = alter;
9    }
10}
11
12Hund rex = new Hund("Rex", 5);  // Konstruktor läuft

Default-Konstruktor: in Java erzeugt der Compiler automatisch einen leeren Konstruktor wenn du keinen schreibst. In Python ist das nicht nötig – __init__ ist optional. Sobald du aber deinen eigenen Konstruktor mit Parametern schreibst, ist der parameterlose nicht mehr automatisch da.

5) Konstruktor-Überladung

Manche Sprachen erlauben mehrere Konstruktoren mit unterschiedlichen Parameterlisten – das nennt sich Überladung. Klassischer Java-Stil:

Konstruktor-Überladung in Java

Hund()

Default: erzeugt Hund mit Standard-Werten. Name "Unbekannt", Alter 0.

Hund(String n)

Nur Name übergeben, Alter wird auf 0 gesetzt.

Hund(String n, int a)

Beide Werte übergeben.

Hund(Hund other)

Copy-Konstruktor: erzeugt eine Kopie eines anderen Hundes.

Python kennt keine Überladung im klassischen Sinn – stattdessen nutzt man Default-Parameter: def __init__(self, name="Unbekannt", alter=0). Eine Funktion mit allen Varianten. Eleganter, weniger Code-Duplikation. Java-Profis nutzen oft Builder-Patterns statt vieler Konstruktoren – mehr in K49.

6) self / this verstehen

Eine Schlüsselfrage für Anfänger: was ist eigentlich self? Klar wird's mit einem konkreten Mental-Modell:

Wenn du eine Methode an einem Objekt aufrufst – rex.bellen() – wird intern die Methode der Klasse aufgerufen und das Objekt als erster Parameter übergeben. self ist dieser Parameter. Innerhalb der Methode bedeutet self.name also „der Name DES Objekts an dem die Methode aufgerufen wurde".

self_demo.pyPython

1class Hund:
2    def __init__(self, name):
3        self.name = name  # speichern AN diesem Objekt
4
5    def bellen(self):
6        print(self.name + ": Wuff!")
7
8rex = Hund("Rex")
9bella = Hund("Bella")
10
11rex.bellen()    # self = rex   → "Rex: Wuff!"
12bella.bellen()  # self = bella → "Bella: Wuff!"

Die gleiche Methode produziert unterschiedliche Ausgaben, je nachdem an welchem Objekt sie aufgerufen wird. Das ist der ganze Trick.

7) Statische und Klassen-Methoden

Manchmal braucht man Methoden die nicht zu einer konkreten Instanz gehören, sondern zur Klasse selbst. Zwei Varianten:

Statische Methode (@staticmethod in Python, static in Java): bekommt weder self noch die Klasse als Parameter. Praktisch eine normale Funktion, die nur logisch zur Klasse gehört.
Klassen-Methode (@classmethod in Python): bekommt die Klasse als Parameter (oft cls genannt). Kann zum Erzeugen alternativer Instanzen nützlich sein.

static_class.pyPython

1class Mathe:
2    PI = 3.14159
3
4    @staticmethod
5    def addiere(a, b):  # kein self!
6        return a + b
7
8# Aufruf OHNE Instanz - direkt über die Klasse:
9Mathe.addiere(3, 5)   # 8
10Mathe.PI              # 3.14159

Klassische Anwendung: Math.sqrt(), Integer.parseInt() in Java – alles statische Methoden. Sie brauchen keinen Objekt-Zustand, fügen sich aber thematisch zur Klasse.

8) Method Chaining

Eine elegante Technik: lass deine Methoden self zurückgeben, dann kannst du sie verketten. Das ergibt fließend lesbaren Code – „fluent interface":

chaining.pyPython

1class Pizza:
2    def __init__(self):
3        self.zutaten = []
4
5    def mit(self, zutat):
6        self.zutaten.append(zutat)
7        return self  # Zurückgeben → Chaining möglich
8
9pizza = Pizza().mit("Schinken").mit("Pilze").mit("Käse")

Du siehst diesen Stil oft in Builder-APIs, jQuery, oder bei Spark/Pandas-DataFrames: df.filter(...).groupBy(...).count().show(). Sehr lesbar wenn richtig eingesetzt.

9) Dunder-Methoden (Magic Methods)

Python hat eine Besonderheit: spezielle Methoden mit doppelten Unterstrichen wie __init__, __str__, __eq__. Sie definieren wie Built-in-Operationen für deine Klasse funktionieren. Genannt „Dunder" (Double UNDERscore) oder „Magic Methods":

Methode	Wofür
`__init__`	Konstruktor
`__str__`	String-Darstellung für `print()`
`__repr__`	Entwickler-freundliche String-Darstellung
`__eq__`	Gleichheits-Check `==`
`__lt__`, `__gt__`, …	Vergleichsoperatoren
`__len__`	Länge mit `len(obj)`
`__iter__`, `__next__`	Iteration mit `for x in obj`
`__add__`	Operator `+`

Mit __add__ kannst du sogar selbstgemachte Klassen mit + kombinieren – Operator-Overloading. In Java geht das nicht, in K41b ist es Standardpraxis.

10) Praktisches Beispiel: ein kleines Spiel

Zum Abschluss eine Klasse die alle drei Bausteine demonstriert. Eine Spieler-Klasse für ein Rollenspiel:

spieler.pyPython

1class Spieler:
  # Klassen-Attribute
  MAX_LEVEL = 100
  XP_PRO_LEVEL = 1000
5
  def __init__(self, name):
      # Instanz-Attribute
      self.name = name
      self.level = 1
      self.xp = 0
      self.gesundheit = 100
12
  def gewinne_xp(self, betrag):
      self.xp += betrag
      while self.xp >= Spieler.XP_PRO_LEVEL:
          self.xp -= Spieler.XP_PRO_LEVEL
          self.level += 1
18
  def erleide_schaden(self, betrag):
      self.gesundheit = max(0, self.gesundheit - betrag)
21
  def ist_tot(self):
      return self.gesundheit == 0
24
  def __str__(self):
      return f"{self.name} (Lvl {self.level})"

Alle Konzepte kombiniert: Klassen-Attribute (Konstanten), Instanz-Attribute (Zustand), Konstruktor (Initialisierung), modifying Methoden (gewinne_xp, erleide_schaden), Query-Methode (ist_tot), Dunder-Methode (__str__). So sieht eine realistische OOP-Klasse aus.

Zusammenfassung

Eine Klasse besteht aus drei Bausteinen: Attributen (Daten), Methoden (Verhalten), Konstruktor (Initialisierung). Klassen-Attribute sind für alle Instanzen gleich, Instanz-Attribute sind pro Objekt unterschiedlich. self (Python) bzw. this (Java/JS) referenziert das aktuelle Objekt in Methoden. Konstruktor-Überladung in Java möglich, in Python via Default-Parameter. Statische Methoden brauchen keine Instanz – Helper-Funktionen unter Klassen-Namensraum. Dunder-Methoden in Python ermöglichen Operator-Überladung und Integration in Built-ins.