Der Bauplan-Trick: Datenstruktur und Verhalten zusammen. Klassen, Konstruktor, Felder, Methoden, this/self. Die Grundlage objektorientierter Programmierung.
Eine Klasse ist ein Bauplan, ein Objekt ist ein konkretes Exemplar nach diesem Bauplan. Beispiel: Klasse Auto definiert Eigenschaften (Marke, Tankfüllung) und Methoden (fahren, tanken). Ein Objekt ist dann ein konkretes Auto wie ein roter VW Golf.
Die zentralen Konzepte für die Klausur:
String marke, int tankfüllung)fahren())In Klausuren wirst du oft gefragt: modelliere [Sachverhalt] als Klasse oder welcher Wert hat das Attribut nach diesen Methodenaufrufen?. Vergiss den Konstruktor nicht, das ist die häufigste Fehlerquelle bei Anfängern.
Stell dir vor du programmierst eine Auto-Verleih-App. Du musst Daten über jedes Auto speichern: Marke, Geschwindigkeit, Tankfüllung. Plus Aktionen: beschleunigen, bremsen, tanken.
Ohne OOP würde das so aussehen:
auto1_marke = "Tesla"
auto1_kmh = 0
auto1_tank = 50
auto2_marke = "VW"
auto2_kmh = 0
auto2_tank = 50
beschleunige_auto(auto1_kmh, auto1_tank) // welche Variablen muss ich ändern?
Bei 100 Autos: 300 Variablen. Bei jedem Auto-Hinzufügen: 3 neue Variablen + alle Methoden anpassen. Albtraum.
Pack die Daten und die Aktionen, die zusammengehören, in eine Klasse. Erzeuge daraus beliebig viele Objekte (= Instanzen) der Klasse.
Eine Klasse ist wie ein Bauplan, ein Objekt wie ein echtes Haus das nach dem Plan gebaut wurde.
Klasse Auto (= Bauplan):
- Felder: marke, kmh, tank
- Methoden: beschleunigen(), bremsen(), tanken()
Objekte (= echte Autos):
auto1 = neues Auto mit marke="Tesla"
auto2 = neues Auto mit marke="VW"
auto1.beschleunigen() // verändert nur auto1, auto2 bleibt
Du baust einen Bauplan und kannst daraus beliebig viele Häuser bauen — jedes mit eigenen Werten, aber gleichen Eigenschaften.
| Im Bild | Im Code | Bedeutung |
|---|---|---|
| Bauplan | Klasse (class) | Definition der Struktur |
| echtes Haus | Objekt / Instanz | konkrete Variable nach Klasse |
| Daten am Haus (Adresse, Farbe) | Feld / Attribut | speichert den State |
| Aktionen am Haus (Tür öffnen) | Methode | Funktion die zum Objekt gehört |
| Bauarbeiter | Konstruktor | erzeugt ein neues Objekt |
Wenn du ein neues Objekt erzeugst, läuft der Konstruktor. Er setzt die Anfangs-Werte der Felder.
In Java: new Auto("Tesla"). In Python: Auto("Tesla").
Der Konstruktor weiß welche Werte er bekommt und schreibt sie in die Felder.
public class Auto {
// Felder
String marke;
int kmh;
int tank;
// Konstruktor
public Auto(String marke) {
this.marke = marke;
this.kmh = 0;
this.tank = 50;
}
// Methoden
public void beschleunigen() {
if (this.tank > 0) {
this.kmh += 20;
this.tank -= 5;
}
}
public void bremsen() {
this.kmh = Math.max(0, this.kmh - 20);
}
public void tanken() {
this.tank = 50;
}
}
// Verwendung
Auto auto1 = new Auto("Tesla");
auto1.beschleunigen(); // kmh wird 20, tank wird 45
auto1.beschleunigen(); // kmh wird 40, tank wird 40
System.out.println(auto1.kmh); // 40In Java schreibst du this.feld. In Python self.feld. Beide bedeuten dasselbe:
"Greif auf das Feld dieser konkreten Instanz zu."
Wenn du innerhalb einer Methode this.kmh schreibst, meinst du das kmh-Feld des Objekts, auf dem die Methode gerade aufgerufen wurde.
auto1.beschleunigen(); // this.kmh ist auto1.kmh
auto2.beschleunigen(); // this.kmh ist auto2.kmh
In Java steuerst du, wer ein Feld lesen darf:
auto1.tank von außen lesbar/schreibbarauto1.tank von außen nicht zugänglichKonvention: Felder sind oft private, Zugriff über Getter und Setter:
private int tank;
public int getTank() { return this.tank; }
public void setTank(int t) { this.tank = t; }
In Python gibt's das offiziell nicht — Konvention: Felder mit Unterstrich am Anfang (_tank) sind als "intern" markiert.
Das ist die Hauptidee von OOP:
Verstecke den State (Felder), erlaube Änderungen nur über Methoden.
So kannst du Regeln durchsetzen. Z.B.: "tank darf nicht negativ werden":
public void beschleunigen() {
if (this.tank > 0) { // Regel im Konstruktor durchsetzen
this.kmh += 20;
this.tank -= 5;
}
}
Würde jemand direkt auto1.tank = -50 setzen, wäre der State kaputt. Mit private + Getter/Setter kannst du das verhindern.
Der ganze Sinn von Klassen: viele Instanzen, jede mit eigenem State.
Auto auto1 = new Auto("Tesla");
Auto auto2 = new Auto("VW");
Auto auto3 = new Auto("BMW");
auto1.beschleunigen();
auto1.beschleunigen();
auto2.beschleunigen();
// auto1.kmh = 40
// auto2.kmh = 20
// auto3.kmh = 0 (nichts gemacht)
Jede Instanz hat ihre eigenen Felder. Ein Methodenaufruf auf auto1 ändert nur auto1.
Wenn mehrere zusammengehörige Daten + Aktionen sich um dieselbe Sache drehen:
| Anwendung | Klasse | Felder | Methoden |
|---|---|---|---|
| Online-Shop | Produkt | name, preis, lager | preisAendern(), bestellen() |
| Banking | Konto | iban, saldo | einzahlen(), abheben() |
| Spiel | Spieler | name, hp, level | angreifen(), aufsteigen() |
| Physik-Simulation | Partikel | x, y, vx, vy | bewegen() |
Praktisch jede größere Software ist aus Klassen aufgebaut. Java und C# sind komplett objektorientiert — du musst Klassen schreiben, sonst geht nichts. Python erlaubt auch ohne Klassen zu programmieren, ist aber für komplexe Programme viel praktischer mit Klassen.
__init__ (Python)auto1.tanken(). Ohne Klammern würde nicht aufgerufen, sondern nur die Methode selbst zurückgegebenauto1.kmh (kein auto1.kmh())Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur — und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Eine Klasse ist ein Bauplan, ein Objekt ist ein konkretes Exemplar nach diesem Bauplan. Beispiel: Klasse Auto definiert Eigenschaften (Marke, Tankfüllung) und Methoden (fahren, tanken). Ein Objekt ist dann ein konkretes Auto wie ein roter VW Golf.
Wie speichert ein Programm Werte? Wie unterscheiden sich int, double, String und boolean?
if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?
for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?
Die zentralen Konzepte für die Klausur:
String marke, int tankfüllung)fahren())In Klausuren wirst du oft gefragt: modelliere [Sachverhalt] als Klasse oder welcher Wert hat das Attribut nach diesen Methodenaufrufen?. Vergiss den Konstruktor nicht, das ist die häufigste Fehlerquelle bei Anfängern.
Stell dir vor du programmierst eine Auto-Verleih-App. Du musst Daten über jedes Auto speichern: Marke, Geschwindigkeit, Tankfüllung. Plus Aktionen: beschleunigen, bremsen, tanken.
Ohne OOP würde das so aussehen:
auto1_marke = "Tesla"
auto1_kmh = 0
auto1_tank = 50
auto2_marke = "VW"
auto2_kmh = 0
auto2_tank = 50
beschleunige_auto(auto1_kmh, auto1_tank) // welche Variablen muss ich ändern?
Bei 100 Autos: 300 Variablen. Bei jedem Auto-Hinzufügen: 3 neue Variablen + alle Methoden anpassen. Albtraum.
Pack die Daten und die Aktionen, die zusammengehören, in eine Klasse. Erzeuge daraus beliebig viele Objekte (= Instanzen) der Klasse.
Eine Klasse ist wie ein Bauplan, ein Objekt wie ein echtes Haus das nach dem Plan gebaut wurde.
Klasse Auto (= Bauplan):
- Felder: marke, kmh, tank
- Methoden: beschleunigen(), bremsen(), tanken()
Objekte (= echte Autos):
auto1 = neues Auto mit marke="Tesla"
auto2 = neues Auto mit marke="VW"
auto1.beschleunigen() // verändert nur auto1, auto2 bleibt
Du baust einen Bauplan und kannst daraus beliebig viele Häuser bauen — jedes mit eigenen Werten, aber gleichen Eigenschaften.
| Im Bild | Im Code | Bedeutung |
|---|---|---|
| Bauplan | Klasse (class) | Definition der Struktur |
| echtes Haus | Objekt / Instanz | konkrete Variable nach Klasse |
| Daten am Haus (Adresse, Farbe) | Feld / Attribut | speichert den State |
| Aktionen am Haus (Tür öffnen) | Methode | Funktion die zum Objekt gehört |
| Bauarbeiter | Konstruktor | erzeugt ein neues Objekt |
Wenn du ein neues Objekt erzeugst, läuft der Konstruktor. Er setzt die Anfangs-Werte der Felder.
In Java: new Auto("Tesla"). In Python: Auto("Tesla").
Der Konstruktor weiß welche Werte er bekommt und schreibt sie in die Felder.
public class Auto {
// Felder
String marke;
int kmh;
int tank;
// Konstruktor
public Auto(String marke) {
this.marke = marke;
this.kmh = 0;
this.tank = 50;
}
// Methoden
public void beschleunigen() {
if (this.tank > 0) {
this.kmh += 20;
this.tank -= 5;
}
}
public void bremsen() {
this.kmh = Math.max(0, this.kmh - 20);
}
public void tanken() {
this.tank = 50;
}
}
// Verwendung
Auto auto1 = new Auto("Tesla");
auto1.beschleunigen(); // kmh wird 20, tank wird 45
auto1.beschleunigen(); // kmh wird 40, tank wird 40
System.out.println(auto1.kmh); // 40Java-Klassen brauchen public/private und explizite Typen. this verweist auf die aktuelle Instanz.
class Auto:
# Konstruktor heisst __init__
def __init__(self, marke):
self.marke = marke
self.kmh = 0
self.tank = 50
# Methoden — self ist immer der erste Parameter
def beschleunigen(self):
if self.tank > 0:
self.kmh += 20
self.tank -= 5
def bremsen(self):
self.kmh = max(0, self.kmh - 20)
def tanken(self):
self.tank = 50
# Verwendung
auto1 = Auto("Tesla")
auto1.beschleunigen() # kmh wird 20, tank wird 45
auto1.beschleunigen() # kmh wird 40, tank wird 40
print(auto1.kmh) # 40Python-Klassen sind kompakter. self statt this. __init__ ist der Konstruktor. Felder werden in __init__ definiert (nicht oben).
In Java schreibst du this.feld. In Python self.feld. Beide bedeuten dasselbe:
"Greif auf das Feld dieser konkreten Instanz zu."
Wenn du innerhalb einer Methode this.kmh schreibst, meinst du das kmh-Feld des Objekts, auf dem die Methode gerade aufgerufen wurde.
auto1.beschleunigen(); // this.kmh ist auto1.kmh
auto2.beschleunigen(); // this.kmh ist auto2.kmh
In Java steuerst du, wer ein Feld lesen darf:
auto1.tank von außen lesbar/schreibbarauto1.tank von außen nicht zugänglichKonvention: Felder sind oft private, Zugriff über Getter und Setter:
private int tank;
public int getTank() { return this.tank; }
public void setTank(int t) { this.tank = t; }
In Python gibt's das offiziell nicht — Konvention: Felder mit Unterstrich am Anfang (_tank) sind als "intern" markiert.
Das ist die Hauptidee von OOP:
Verstecke den State (Felder), erlaube Änderungen nur über Methoden.
So kannst du Regeln durchsetzen. Z.B.: "tank darf nicht negativ werden":
public void beschleunigen() {
if (this.tank > 0) { // Regel im Konstruktor durchsetzen
this.kmh += 20;
this.tank -= 5;
}
}
Würde jemand direkt auto1.tank = -50 setzen, wäre der State kaputt. Mit private + Getter/Setter kannst du das verhindern.
Der ganze Sinn von Klassen: viele Instanzen, jede mit eigenem State.
Auto auto1 = new Auto("Tesla");
Auto auto2 = new Auto("VW");
Auto auto3 = new Auto("BMW");
auto1.beschleunigen();
auto1.beschleunigen();
auto2.beschleunigen();
// auto1.kmh = 40
// auto2.kmh = 20
// auto3.kmh = 0 (nichts gemacht)
Jede Instanz hat ihre eigenen Felder. Ein Methodenaufruf auf auto1 ändert nur auto1.
Wenn mehrere zusammengehörige Daten + Aktionen sich um dieselbe Sache drehen:
| Anwendung | Klasse | Felder | Methoden |
|---|---|---|---|
| Online-Shop | Produkt | name, preis, lager | preisAendern(), bestellen() |
| Banking | Konto | iban, saldo | einzahlen(), abheben() |
| Spiel | Spieler | name, hp, level | angreifen(), aufsteigen() |
| Physik-Simulation | Partikel | x, y, vx, vy | bewegen() |
Praktisch jede größere Software ist aus Klassen aufgebaut. Java und C# sind komplett objektorientiert — du musst Klassen schreiben, sonst geht nichts. Python erlaubt auch ohne Klassen zu programmieren, ist aber für komplexe Programme viel praktischer mit Klassen.
__init__ (Python)auto1.tanken(). Ohne Klammern würde nicht aufgerufen, sondern nur die Methode selbst zurückgegebenauto1.kmh (kein auto1.kmh())Zwei Instanzen der Klasse Auto nebeneinander. Klick auf eine Methode bei einer Instanz und beobachte: nur diese Instanz ändert sich. Die andere bleibt stehen.
Probier folgendes:
Interaktive Visualisierung
Zeigt Klassen-Definition und mehrere Instanzen mit individuellen Attribut-Werten.
Faustregel zum Mitnehmen: Eine Klasse ist ein Bauplan, ein Objekt ist ein konkretes Ding. Aus EINEM Bauplan baust du beliebig viele Objekte — jedes mit eigenem State, alle nutzen dieselben Methoden.
Wenn du in der Klausur den Unterschied erklären sollst: nutz das Bauplan-Bild. "Klasse = Bauplan, Objekt = das gebaute Haus."
Klausurfragen mit Lösungen (8)
Antwort: Klasse ist der Bauplan, Objekt ist eine konkrete Instanz
Erklärung: Klasse = Bauplan / Definition. Objekt (Instanz) = konkretes Ding nach diesem Bauplan. Aus einer Klasse können beliebig viele Objekte erzeugt werden, jedes mit eigenem State.
Antwort: __init__
Erklärung: In Python heißt der Konstruktor __init__ (mit zwei Unterstrichen davor und danach). In Java heißt er gleich wie die Klasse. In beiden setzt er die Anfangs-Werte der Felder.
Antwort: Das Feld der aktuellen Instanz, auf der die Methode aufgerufen wurde
Erklärung: this verweist auf die aktuelle Instanz. Bei auto1.beschleunigen() ist this = auto1, bei auto2.beschleunigen() ist this = auto2. So unterscheidet die Methode zwischen verschiedenen Instanzen.
Auto a = new Auto("Tesla");
Auto b = new Auto("VW");
a.beschleunigen();
a.beschleunigen();
b.beschleunigen();
System.out.println(a.kmh + " " + b.kmh);Antwort: 40 20
Erklärung: Jedes beschleunigen() addiert 20 km/h zur jeweiligen Instanz. a wurde 2× beschleunigt = 40 km/h. b wurde 1× beschleunigt = 20 km/h. Wichtig: a und b sind unabhängig, jeder hat eigenen State.
Antwort: Felder sind oft private und nur über Methoden zugänglich
Erklärung: Encapsulation = Felder verstecken (private), Zugriff nur über Methoden (Getter/Setter). Vorteil: Du kannst Regeln durchsetzen (z.B. 'tank darf nicht negativ werden'). Java hat das fest mit private/public, in Python ist es eine Konvention (Unterstrich-Prefix).
public class Auto {
int kmh;
public void beschleunigen() {
kmh += 20;
}
}
Auto auto = new Auto();
auto.beschleunigen;Antwort: Methoden brauchen Klammern () zum Aufrufen
Erklärung: auto.beschleunigen ist falsch — ohne () wird die Methode NICHT ausgeführt, sondern nur referenziert. Korrekt: auto.beschleunigen(). Klammern signalisieren 'jetzt aufrufen'.
Antwort: Beliebig viele, jedes mit eigenem State
Erklärung: Eine Klasse ist ein Bauplan. Aus einem Bauplan kann man beliebig viele Häuser bauen. Jedes Objekt hat seinen eigenen State (eigene Felder), aber alle nutzen dieselben Methoden (definiert in der Klasse).
Antwort: OOP gruppiert zusammengehörige Daten + Aktionen, was die Wartung erleichtert
Erklärung: OOP gruppiert State (Felder) und Verhalten (Methoden) in einer Einheit (Klasse). Das macht Code übersichtlicher, vor allem bei großen Programmen mit vielen ähnlichen Entitäten (Autos, User, Bestellungen). Performance ist meist gleich oder leicht schlechter (mehr Indirektion).
Funktionen, die sich selbst aufrufen. Mit Call-Stack-Visualisierung am Beispiel Fakultät.