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).
Erklärung
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. Du lernst hier, wie Klassen Daten und Verhalten bündeln, wie Konstruktoren Objekte initialisieren, wie this/self auf die aktuelle Instanz zeigt, warum private Felder mit Getter/Setter Regeln schützen, und warum zwei Variablen auf dasselbe Objekt zeigen können (Aliasing). Pflichtstoff im 1. Semester Informatik und Wirtschaftsinformatik.
Die zentralen Konzepte für die Klausur:
- Attribute / Felder: Eigenschaften der Klasse (z.B.
String marke,int tankfüllung) - Methoden: Funktionen die zur Klasse gehören (z.B.
fahren()) - Konstruktor: spezieller Initialisierungsblock, der beim Erzeugen eines Objekts aufgerufen wird. In Java heißt er wie die Klasse und hat kein return-Type-Keyword (auch nicht
void), Konstruktoren sind spezielle Initialisierungsblöcke, keine regulären Methoden. In Python übernimmt__init__die Initialisierung des bereits erzeugten Objekts (der eigentliche Objekt-Erzeugungs-Hook__new__ist im Grundlagenkurs selten relevant). - this (Java) / self (Python): Referenz auf das aktuelle Objekt
- Sichtbarkeit (private/public): kontrolliert wer auf Felder und Methoden zugreifen darf
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.
Das Problem
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.
Die Idee
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.
Die Fachbegriffe
| 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 |
Der Konstruktor
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.
So sieht das im Code aus
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() {
// braucht 5 Tankpunkte; Bedingung ist >= 5,
// damit tank nicht negativ werden kann
if (this.tank >= 5) {
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, Felder und Methoden können public, private, protected oder package-private (kein Modifier = Default) sein. In gut gekapselten Klassen sind Felder typischerweise private. this verweist auf die aktuelle Instanz und ist außerhalb von Namenskonflikten oft optional.
class Auto:
# Initialisierungsmethode heißt __init__
def __init__(self, marke):
self.marke = marke
self.kmh = 0
self.tank = 50
# Methoden, self ist immer der erste Parameter
def beschleunigen(self):
# braucht 5 Tankpunkte; Bedingung ist >= 5,
# damit tank nicht negativ werden kann
if self.tank >= 5:
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__` initialisiert das Objekt nach der Erzeugung; den eigentlichen Erzeugungs-Hook `__new__` braucht man im Grundlagenkurs selten. **Instanzattribute** werden typischerweise in __init__ gesetzt (self.feld). Attribute, die direkt im Klassenkörper stehen, sind **Klassenattribute** und werden von allen Instanzen geteilt.
this und self
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
Zugriffsrechte: public vs private
In Java steuern Sichtbarkeitsmodifier den Zugriff auf Felder, Methoden und Konstruktoren, also Lesen, Schreiben und Aufrufen:
- public: jeder darf zugreifen
- private: nur die Klasse selbst
- protected: Klasse + Subklassen + selbes Package
- kein Modifier (package-private): alle Klassen im selben Package
Konvention: Felder sind oft private, Zugriff über Getter und Setter mit Validierung:
private int tank;
public int getTank() { return this.tank; }
public void setTank(int t) {
if (t < 0) throw new IllegalArgumentException("tank darf nicht negativ sein");
this.tank = Math.min(t, 50); // Obergrenze 50 durchsetzen
}
Ein Setter ohne Validierung (
this.tank = t;) demonstriert keine echte Kapselung, die Regel "tank darf nicht negativ werden" muss durchgesetzt werden.
In Python gibt's keinen erzwungenen private-Modifier wie in Java:
_tank(ein Unterstrich) ist Konvention für "intern, nicht öffentlich".__tank(zwei Unterstriche) löst Name Mangling aus (_Klassenname__tank), ist aber kein echter Zugriffsschutz.
Encapsulation (Kapselung)
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 >= 5) { // Regel in der Methode 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.
Mehrere Instanzen
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.
Wann nutzt man Klassen?
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 ist klassenbasiert, Programmcode steht in Klassen, und Methoden gehören zu Klassen oder Objekten. Python erlaubt auch freie Funktionen ohne eigene Klassen, ist aber für komplexe Programme viel praktischer mit Klassen.
Klausur-Tricks
- Klasse vs Objekt: die Klasse ist der Bauplan, das Objekt eine konkrete Instanz. Es gibt EINE Klasse, aber BELIEBIG VIELE Instanzen.
- Konstruktor heißt wie die Klasse (Java) oder
__init__(Python) - this/self: Java
thisist außerhalb von Namenskonflikten oft optional (instatic-Methoden gibt es keinthis). Python verlangtselfexplizit als erstes Argument von Instanzmethoden, der Nameselfist Konvention, nicht Schlüsselwort. - Methodenaufrufe brauchen Klammern:
auto1.tanken(). Ohne Klammern wird die Methode nicht aufgerufen (Python liefert das Methodenobjekt, Java meldet Compile-Fehler bei reinemauto.beschleunigen;. Methodenreferenzen brauchen die spezielle::-Syntax und müssen einem funktionalen Interface zugewiesen werden) - Felder werden ohne Klammern angesprochen:
auto1.kmh(keinauto1.kmh())
Interaktiv
Klassen + Objekte live
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:
- beschleunigen auf auto1 → kmh +20, tank −5. auto2 unverändert.
- Mehrmals beschleunigen auf auto1 bis Tank leer → die Methode prüft den Tank, blockt wenn 0
- bremsen bringt kmh auf 0, aber nicht negativ (Math.max-Schutz)
- tanken füllt zurück auf 50, und du kannst weiterfahren
- Versuch beide Autos in den gleichen Zustand zu bringen (selbe Operationen in selber Reihenfolge)
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."
Code-Stepper: Klausur-Klassiker durchspielen
Drei interaktive Demos zu den häufigsten Klausur-Stolperern bei Klassen und Objekten: Konstruktor + this (Felder werden initialisiert), zwei Referenzen, ein Objekt (Mutation über eine Variable ist über die andere sichtbar) und equals() überschreiben (sonst vergleicht == nur Referenzen). Klicke auf Step oder Auto.
1. Konstruktor + this: Felder initialisieren
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
2. Zwei Referenzen, ein Objekt: Mutation ist von überall sichtbar
Wenn zwei Variablen auf dasselbe Objekt zeigen, ist eine Änderung über die eine auch über die andere sichtbar. Klausur-Klassiker und häufiger Bug.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
3. equals() überschreiben: == bleibt Referenzvergleich, equals() kann Wertvergleich sein
Bei selbst-definierten Klassen liefert == immer false bei zwei verschiedenen Objekten, auch wenn die Felder identisch sind. Wer Wert-Vergleich will, muss equals() (und hashCode()) überschreiben.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Quiz
Klausurfragen mit Lösungen (8)
- F1.Was ist der Unterschied zwischen Klasse und Objekt?
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.
- F2.Welche Methode initialisiert ein neues Objekt in Python?
Antwort: __init__
Erklärung: `__init__` (mit zwei Unterstrichen davor und danach) initialisiert das Objekt in Python. Streng genommen erzeugt `__new__` das Objekt, `__init__` initialisiert es danach. Im Grundlagenkurs nutzt du nur `__init__`. In Java heißt der Konstruktor gleich wie die Klasse. In beiden Sprachen setzt er die Anfangs-Werte der Felder.
- F3.Was bedeutet this.feld in einer Java-Methode?
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.
- F4.Was passiert in diesem Code?
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.
- F5.Welche Aussage über Encapsulation (Kapselung) stimmt?
Antwort: Felder sind oft private und nur über Methoden zugänglich
Erklärung: Encapsulation = Felder verstecken (private), Zugriff nur über Methoden (Getter/Setter mit Validierung). Vorteil: Du kannst Regeln durchsetzen (z.B. 'tank darf nicht negativ werden'). Java unterstützt Kapselung mit **private, public, protected und package-private**; private Felder erzwingen Zugriff nur innerhalb der Klasse. In Python ist es Konvention (\_tank für intern, \_\_tank für Name Mangling, kein echter Schutz wie Java private).
- F6.Was ist falsch an diesem Java-Code?
Antwort: Methoden brauchen Klammern () zum Aufrufen
Erklärung: **Java**: `auto.beschleunigen;` ist kein gültiger Methodenaufruf und führt zu einem **Compile-Fehler**, nicht einfach 'Methode wird nur referenziert'. Methodenreferenzen brauchen die spezielle Syntax `auto::beschleunigen` und sind kein direkter Aufruf, sondern werden einem funktionalen Interface zugewiesen (Lambda-Kontext). **Python**: `auto.beschleunigen` (ohne Klammern) liefert tatsächlich ein gebundenes Methodenobjekt, ruft die Methode aber nicht auf. In beiden Fällen ist der Aufruf-korrekte Code `auto.beschleunigen()`.
- F7.Wie viele Objekte können aus einer Klasse erzeugt werden?
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).
- F8.Welcher Vorteil bietet OOP gegenüber prozeduraler Programmierung?
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 nicht der Hauptgrund für OOP; der Vorteil liegt vor allem in Struktur, Wartbarkeit und Modellierung.
Auto a = new Auto("Tesla");
Auto b = new Auto("VW");
a.beschleunigen();
a.beschleunigen();
b.beschleunigen();
System.out.println(a.kmh + " " + b.kmh);public class Auto {
int kmh;
public void beschleunigen() {
kmh += 20;
}
}
Auto auto = new Auto();
auto.beschleunigen;
