Aufgaben OOP
Die letzte Lektion von K48: 10 typische IHK-Aufgaben zu OOP. Sie decken alle vorherigen Lektionen ab – von Klassen-Definition bis SOLID. Manche sind reine Wissensfragen wie sie als Multiple-Choice oder Kurzantwort vorkommen, andere kleine Code-Aufgaben, und manche kombinieren UML-Lesen mit Code-Schreiben.
Versuch jede Aufgabe erst selbst, bevor du die Lösung aufklappst. Du lernst mehr aus einer falschen Antwort und der Erklärung als aus dem reinen Mitlesen.
1) Vorbereitung: Cheat-Sheet OOP
Vor den Aufgaben ein kompaktes Cheat-Sheet aller wichtigen OOP-Begriffe aus dem Kurs. Falls einer davon noch fremd ist, geh in die entsprechende Lektion zurück:
OOP-Cheat-Sheet
Grundbegriffe
Klasse
Bauplan, definiert Attribute + Methoden
Objekt
Konkrete Instanz einer Klasse
Instanziierung
Objekt erzeugen mit new / Konstruktor
Konstruktor
Methode, läuft beim Erzeugen
Vier OOP-Säulen
Kapselung
Daten + Methoden bündeln, Interna verbergen
Vererbung
Klasse erbt von anderer (is-a)
Polymorphismus
Gleicher Aufruf, anderes Verhalten
Abstraktion
Wesentliches herausheben (Interfaces)
SOLID
S - Single Responsibility
Eine Klasse, eine Verantwortung
O - Open/Closed
Offen f. Erweiterung, geschl. f. Modifikation
L - Liskov Substitution
Subtypen müssen ersetzbar sein
I - Interface Segregation
Kleine fokussierte Interfaces
D - Dependency Inversion
Auf Abstraktionen verlassen
UML-Symbole
+ / # / − / ~
public / protected / private / package
───▷
Vererbung (durchgezogen)
┄┄▷
Interface-Implementierung (gestrichelt)
◇──── / ◆────
Aggregation / Komposition
Vor IHK-Prüfungen lohnt es sich diese Tabelle 1-2 Mal komplett durchzulesen. Die Vier Säulen und SOLID sind absolute Pflicht – das wird in jeder OOP-Klausur in irgendeiner Form abgefragt.
2) Aufgabe 1: Klassen-Definition
Klassische Einstiegs-Aufgabe: gegeben eine textuelle Beschreibung, dazu eine Java-Klasse schreiben. Solche Aufgaben tauchen in fast jeder Programmier-Klausur auf. Achte auf Kapselung und die korrekte Getter-Konvention.
AUFGABE #1
EASY
Schreibe eine Java-Klasse
Buch mit den Attributen titel (String), autor (String) und seitenzahl (int). Alle Attribute sollen private sein. Erstelle einen Konstruktor und Getter für alle Attribute, sowie eine toString-Methode.✓ Lösung
public class Buch {
private String titel;
private String autor;
private int seitenzahl;
public Buch(String titel, String autor, int seitenzahl) {
this.titel = titel;
this.autor = autor;
this.seitenzahl = seitenzahl;
}
public String getTitel() { return titel; }
public String getAutor() { return autor; }
public int getSeitenzahl() { return seitenzahl; }
@Override
public String toString() {
return titel + " von " + autor + " (" + seitenzahl + " S.)";
}
}
Bewertungspunkte:
- Alle Attribute
private✓ (Kapselung, siehe L4) - Konstruktor mit allen Parametern ✓
this.bei Zuweisungen um Parameter-Schatten zu vermeiden ✓- Getter für jedes Attribut ✓ (Konvention:
getXxx()) toString()mit@Override✓
3) Aufgabe 2: Wissensfrage Kapselung
Klassische Theorie-Frage. So etwas kommt in Multiple-Choice oder als kurze Erklärung. Du musst die Begriffe sicher verwenden können – nicht nur ihr Konzept verstehen.
AUFGABE #2
EASY
Erkläre den Begriff „Kapselung" und nenne zwei konkrete Vorteile. Welche Sichtbarkeits-Schlüsselwörter gibt es in Java?
✓ Lösung
Definition: Kapselung ist das Bündeln von Daten und Methoden in einer Klasse und das Verbergen interner Details vor anderen Klassen. Andere Klassen sollen nur über öffentliche Methoden mit dem Objekt interagieren.Vorteile (mind. zwei nennen):
- Wartbarkeit: interne Änderungen wirken sich nicht auf andere Code-Stellen aus, solange die öffentliche Schnittstelle stabil bleibt
- Datenintegrität: Validierung in Setter-Methoden verhindert ungültige Werte
- Sicherheit: sensible Daten können nicht direkt von außen manipuliert werden
- Klarheit: die öffentliche API ist klein und gut dokumentierbar
public (überall zugreifbar), protected (Klasse + Unterklassen + selbe Package), private (nur eigene Klasse), sowie kein Modifier = package-private (selbe Package).Mehr in L4 Kapselung.
4) Aufgabe 3: Vererbung mit super()
Eine sehr beliebte Klausur-Aufgabe: gegeben eine Basisklasse, schreibe eine Unterklasse mit zusätzlichen Attributen und Methoden. Achte besonders auf den korrekten Aufruf des Eltern-Konstruktors mit super().
AUFGABE #3
MEDIUM
Gegeben sei die Klasse
Fahrzeug mit Attributen marke und baujahr. Erweitere sie um eine Unterklasse Auto, die zusätzlich ein Attribut tueren hat. Schreibe den Konstruktor von Auto so, dass marke und baujahr an die Oberklasse weitergegeben werden.✓ Lösung
public class Fahrzeug {
protected String marke;
protected int baujahr;
public Fahrzeug(String marke, int baujahr) {
this.marke = marke;
this.baujahr = baujahr;
}
}
public class Auto extends Fahrzeug {
private int tueren;
public Auto(String marke, int baujahr, int tueren) {
super(marke, baujahr); // MUSS erste Zeile sein!
this.tueren = tueren;
}
}
Wichtige Punkte:
extends Fahrzeugfür die Vererbungs-Beziehungsuper(marke, baujahr)muss erste Zeile im Auto-Konstruktor sein (Java-Regel)- Attribute der Oberklasse sind
protected→ in Unterklasse zugreifbar - Eigenes Attribut
tuerennach super-Aufruf setzen
5) Aufgabe 4: UML-Diagramm lesen
Eine sehr typische Klausuraufgabe: gegeben ist ein UML-Diagramm – beschreibe was du dort siehst. Achte besonders auf die Bedeutung der Symbole. Welche Beziehung ist gemeint?
AUFGABE #4
MEDIUM
Gegeben sei folgendes UML-Diagramm. Beschreibe die Beziehungen und welche Aussagen sich daraus ableiten lassen:
[Mitarbeiter]
+ name : String
+ gehalt : double
+ getGehalt() : double
[Manager] ────▷ [Mitarbeiter]
[Manager] ◇── 1..* [Mitarbeiter]
✓ Lösung
Aussagen aus dem Diagramm:
- Manager ist Unterklasse von Mitarbeiter – durchgezogener Pfeil mit Dreieck-Spitze ist Vererbung. Ein Manager ist auch ein Mitarbeiter.
- Manager hat 1..* Mitarbeiter – die leere Raute steht für Aggregation. Jeder Manager hat mindestens einen, möglicherweise viele Mitarbeiter unter sich.
- Aggregation, nicht Komposition: die Mitarbeiter existieren unabhängig vom Manager. Wenn der Manager wechselt, leben die Mitarbeiter weiter.
- Manager erbt die Attribute name, gehalt und die Methode getGehalt() von Mitarbeiter.
public class Mitarbeiter {
public String name;
public double gehalt;
public double getGehalt() { return gehalt; }
}
public class Manager extends Mitarbeiter {
private List<Mitarbeiter> team; // 1..* Aggregation
}
Klassischer Hinweis: bei Aggregation hat das Aggregat-Objekt eine Referenz auf das Teil-Objekt, aber „besitzt" es nicht. Mehr zu UML in L8.
6) Aufgabe 5: Polymorphismus implementieren
Eine kombinierte Aufgabe: Code und Konzept. Solche Fragen testen, ob du Polymorphismus nicht nur kennst, sondern auch implementieren kannst. Achte darauf: keine if-Abfragen in der Hauptmethode!
AUFGABE #5
MEDIUM
Erstelle eine abstrakte Klasse
Form mit einer abstrakten Methode flaeche(). Erstelle zwei konkrete Unterklassen Kreis und Rechteck mit eigener Implementierung. Schreibe eine Hauptmethode, die für eine Liste aus verschiedenen Formen die Flächen ausgibt – ohne if-Abfragen!✓ Lösung
public abstract class Form {
public abstract double flaeche();
}
public class Kreis extends Form {
private double radius;
public Kreis(double radius) { this.radius = radius; }
@Override
public double flaeche() {
return Math.PI * radius * radius;
}
}
public class Rechteck extends Form {
private double breite, hoehe;
public Rechteck(double b, double h) {
this.breite = b; this.hoehe = h;
}
@Override
public double flaeche() {
return breite * hoehe;
}
}
// Verwendung mit Polymorphismus:
List<Form> formen = List.of(new Kreis(5), new Rechteck(3, 4));
for (Form f : formen) {
System.out.println(f.flaeche()); // kein if-Block!
}
Bewertungspunkte:
abstract classfür Form,abstract-Methode ohne Body ✓- Beide Unterklassen überschreiben flaeche mit
@Override - Hauptmethode arbeitet mit dem Oberklasse-Typ Form
- Keine
instanceof-Abfragen oder if-elif – die Klassen wissen selbst was zu tun ist (Polymorphismus!)
7) Aufgabe 6: Interface vs. abstrakte Klasse
Eine sehr häufig gestellte Wissensfrage in Klausuren und Bewerbungsgesprächen. Wenn du diese Unterscheidung nicht parat hast, fällst du in Theorie-Prüfungen auf. Lerne mindestens vier konkrete Unterschiede.
AUFGABE #6
MEDIUM
Nenne mindestens vier Unterschiede zwischen einer abstrakten Klasse und einem Interface in Java. Wann würdest du was wählen?
✓ Lösung
Unterschiede (mind. vier):
- Konkrete Methoden mit Implementierung: abstrakte Klasse kann, Interface (klassisch) nicht – seit Java 8 sind aber Default-Methoden in Interfaces möglich
- Felder/Zustand: abstrakte Klasse kann normale Felder haben (private, protected, etc.), Interface nur
public static finalKonstanten - Konstruktor: abstrakte Klasse ja, Interface nein
- Mehrfachnutzung: eine Klasse kann nur eine abstrakte Klasse erweitern (
extends), aber mehrere Interfaces implementieren (implements) - Sichtbarkeitsmodifikatoren: in abstrakten Klassen frei wählbar, in Interfaces sind alle Methoden implizit
public
- Abstrakte Klasse: wenn mehrere verwandte Klassen gemeinsame Implementierung teilen sollen (is-a-Hierarchie mit gemeinsamen Code)
- Interface: wenn völlig verschiedene Klassen dieselbe Fähigkeit haben sollen (can-do-Verträge); oder wenn Mehrfach-Implementierung gebraucht wird
8) Aufgabe 7: Diamond-Problem
Eine etwas anspruchsvollere Frage zur Mehrfachvererbung. Das Diamond-Problem ist ein Klassiker der OOP-Theorie und in Bewerbungsgesprächen für FIAE-Stellen oft Thema. Bei FIAE-Abschlussprüfungen kommt's regelmäßig dran.
AUFGABE #7
HARD
Was ist das Diamond-Problem in der OOP? Wie lösen es Java, Python und C++? Skizziere den Sachverhalt mit einem Diagramm.
✓ Lösung
Sachverhalt: bei Mehrfachvererbung kann eine Klasse D von zwei Klassen B und C erben, die beide wiederum von einer gemeinsamen Basis A erben. Die Hierarchie sieht aus wie eine Raute (Diamond):
[A]
/ \
[B] [C]
\ /
[D]
Das Problem: wenn A eine Methode m() hat, die B und C überschreiben – welche Version erbt D? Es gibt keine eindeutige Antwort.Lösungen pro Sprache:
- Java: Mehrfachvererbung von Klassen ist verboten. Stattdessen kann eine Klasse mehrere Interfaces implementieren, da Interfaces (klassisch) keinen Zustand haben. Ab Java 8 mit Default-Methoden kann's wieder kompliziert werden – dann muss die implementierende Klasse die Methode explizit überschreiben.
- Python: nutzt eine algorithmische Lösung namens C3 Linearization. Die Reihenfolge im
class D(B, C)-Statement bestimmt die Such-Reihenfolge – B kommt vor C. Sichtbar überD.__mro__. - C++: bietet virtuelle Vererbung mit dem Schlüsselwort
virtual. Klassen, die virtuell von A erben, teilen sich eine A-Instanz. Komplex und fehleranfällig.
9) Aufgabe 8: SOLID-Verstoß erkennen
Du bekommst Code zu sehen und sollst erkennen, welches SOLID-Prinzip verletzt wurde. Das ist typisch für Bewerbungsgespräche – die Firma will sehen, ob du Code-Smells erkennen kannst. Schau dir die if-elif-Kette genau an.
AUFGABE #8
HARD
Welches SOLID-Prinzip wird im folgenden Code verletzt? Wie würdest du den Code refactoren?
class Mitarbeiter:
def __init__(self, typ, name, gehalt):
self.typ = typ # "fest" oder "praktikant"
self.name = name
self.gehalt = gehalt
def berechne_netto(self):
if self.typ == "fest":
return self.gehalt * 0.7
elif self.typ == "praktikant":
return self.gehalt * 0.85
elif self.typ == "freelancer":
return self.gehalt * 0.6
✓ Lösung
Verletztes Prinzip: Open/Closed-Prinzip (OCP). Der Code muss bei jedem neuen Mitarbeiter-Typ modifiziert werden – ein neuer elif-Zweig kommt rein. Das ist genau das, was OCP verhindern will: bestehender Code soll geschlossen für Modifikation, aber offen für Erweiterung sein.Sekundär könnte man auch eine SRP-Verletzung argumentieren: die Klasse Mitarbeiter ist verantwortlich für viele verschiedene Typen mit unterschiedlicher Logik.
Refactoring mit Polymorphismus:
from abc import ABC, abstractmethod
class Mitarbeiter(ABC):
def __init__(self, name, gehalt):
self.name = name
self.gehalt = gehalt
@abstractmethod
def berechne_netto(self): pass
class Festangestellter(Mitarbeiter):
def berechne_netto(self):
return self.gehalt * 0.7
class Praktikant(Mitarbeiter):
def berechne_netto(self):
return self.gehalt * 0.85
class Freelancer(Mitarbeiter):
def berechne_netto(self):
return self.gehalt * 0.6
Vorteil: neuer Mitarbeiter-Typ? Einfach neue Klasse erstellen – kein bestehender Code muss angefasst werden. Mehr in L9 SOLID.
10) Aufgabe 9: Komplettes UML zu Code
Eine umfangreichere Aufgabe: gegeben ist ein UML-Diagramm, daraus soll vollständiger Code entstehen. Solche Aufgaben tauchen in größeren Klausuren auf, oft als Hauptaufgabe mit mehreren Teil-Punkten. Mehrfach-Implementierung und abstrakte Klassen sind kombiniert.
AUFGABE #9
HARD
Setze folgendes UML-Diagramm in Java-Code um. Achte auf korrekte Sichtbarkeit und vollständige Implementierung:
«interface» Druckbar
+ drucken() : void
Dokument (abstract)
− titel : String
+ getTitel() : String
+ inhalt() : String (abstract)
Brief ───▷ Dokument, ┄┄▷ Druckbar
− empfaenger : String
+ inhalt() : String
+ drucken() : void
✓ Lösung
public interface Druckbar {
void drucken();
}
public abstract class Dokument {
private String titel;
public Dokument(String titel) {
this.titel = titel;
}
public String getTitel() { return titel; }
public abstract String inhalt();
}
public class Brief extends Dokument implements Druckbar {
private String empfaenger;
public Brief(String titel, String empfaenger) {
super(titel);
this.empfaenger = empfaenger;
}
@Override
public String inhalt() {
return "Sehr geehrte/r " + empfaenger + ", ...";
}
@Override
public void drucken() {
System.out.println(getTitel() + ": " + inhalt());
}
}
Bewertungspunkte:
- Interface mit Methoden-Signatur ohne Implementierung ✓
- Abstrakte Klasse mit
abstractmarkiert ✓ - Abstrakte Methode
inhalt()ohne Body ✓ privateAttribute,publicGetter ✓- Brief erbt von Dokument UND implementiert Druckbar (Mehrfach-Implementierung erlaubt!) ✓
super(titel)im Brief-Konstruktor ✓- Beide abstrakten/Interface-Methoden implementiert mit
@Override✓
11) Aufgabe 10: Die vier OOP-Säulen
Die finale Frage – eine klassische Konzept-Frage, die in fast jeder OOP-Klausur erscheint. Hier zeigt sich, ob du die großen Ideen der OOP verstanden hast. Lerne die vier Begriffe mit jeweils einer Definition und einem Beispiel auswendig.
AUFGABE #10
HARD
Nenne und erkläre kurz die vier Säulen der OOP. Gib für jede Säule ein konkretes Code-Beispiel oder eine Real-Welt-Analogie an.
✓ Lösung
- Kapselung (Encapsulation)
- Definition: Bündelung von Daten und Methoden in einer Klasse, Verbergen interner Details
- Beispiel:
private double saldo, Zugriff nur übereinzahlen()/getSaldo() - Analogie: Mikrowelle – nur Bedienknopf außen, Magnetron versteckt
- Vererbung (Inheritance)
- Definition: Klasse erbt Attribute/Methoden von einer anderen, kann sie erweitern/überschreiben
- Beispiel:
class Hund extends Tier– Hund erbt name, fressen() von Tier - Analogie: biologische Vererbung – Sohn erbt Eigenschaften vom Vater
- Polymorphismus (Polymorphism)
- Definition: gleicher Methodenname produziert verschiedenes Verhalten je nach Objekttyp
- Beispiel:
hund.laut_geben()bellt,katze.laut_geben()miaut – gleicher Aufruf - Analogie: ein Lichtschalter bedient verschiedene Lampen unterschiedlich
- Abstraktion (Abstraction)
- Definition: Wesentliches herausheben, Implementierungsdetails verstecken (über abstrakte Klassen, Interfaces)
- Beispiel:
interface ZahlbarmitberechneBetrag()– Rechnung und Gehalt implementieren es verschieden - Analogie: Autofahren – Bedienung Lenkrad/Pedale, Innenleben des Motors unwichtig
12) Bonus: Begriffs-Übersicht
Zum Abschluss eine Tabelle mit allen wichtigen Begriffen und Kurzdefinitionen, die du sicher beherrschen solltest. Falls einer noch unklar ist, geh in die entsprechende Lektion zurück:
| Begriff | Bedeutung | Lektion |
|---|---|---|
| Klasse | Bauplan/Schablone für Objekte | L2 |
| Objekt / Instanz | Konkretes Exemplar einer Klasse | L2 |
| Attribut / Feld | Datenmember einer Klasse | L3 |
| Methode | Funktion, die zur Klasse gehört | L3 |
| Konstruktor | Spezielle Methode zur Initialisierung | L3 |
| this / self | Referenz auf das aktuelle Objekt | L3 |
| Kapselung | Daten + Methoden bündeln, Interna verstecken | L4 |
| Sichtbarkeitsmodifikator | public, protected, private (Zugriff) | L4 |
| Vererbung | Klasse übernimmt Eigenschaften einer anderen | L5 |
| super() | Aufruf der Oberklassen-Methode | L5 |
| Override | Methode der Oberklasse überschreiben | L5 |
| Polymorphismus | Gleicher Aufruf, anderes Verhalten | L6 |
| Abstrakte Klasse | Nicht instanziierbar, kann abstrakte Methoden enthalten | L7 |
| Interface | Methoden-Vertrag ohne Zustand | L7 |
| UML | Unified Modeling Language, grafische Notation | L8 |
| SOLID | Fünf Designprinzipien für sauberen OOP-Code | L9 |
13) Prüfungs-Tipps
Prüfungs-Checkliste OOP
- Vier Säulen beherrschen: Kapselung, Vererbung, Polymorphismus, Abstraktion – Definition + Beispiel parat
- UML-Notation lesen können: Vererbung, Aggregation, Komposition, Multiplizitäten
- Interface vs. abstrakte Klasse: mindestens vier Unterschiede sicher aufzählen
- Java/Python-Syntax: Klasse, Konstruktor, Vererbung, Override in beiden Sprachen schreiben können
- SOLID-Buchstaben kennen: S/O/L/I/D mit Kurzdefinition
- Diamond-Problem: Was es ist, wie Java/Python es lösen
- Code-Smells erkennen: lange if-elif-Ketten = potentieller OCP-Verstoß
- UML zu Code übersetzen: Praxisaufgabe in vielen Klausuren – üben!
14) Wie geht's weiter?
Mit K48 hast du das OOP-Fundament gelegt. Was du als nächstes vertiefen kannst:
- Design Patterns: K49 baut direkt auf K48 auf. Bekannte Patterns wie Singleton, Factory, Strategy, Observer – sie alle nutzen OOP-Konzepte.
- Java Fortgeschritten: K40b – Generics, Lambdas, Streams, Concurrency. Erweitert dein OOP-Wissen um moderne Java-Features.
- Python Fortgeschritten: K41b – Dunder-Methods, Decorators, Metaclasses, Type Hints. OOP auf Python-Profi-Niveau.
- Clean Code lesen: Robert C. Martins Bücher „Clean Code" und „Clean Architecture" sind Pflichtlektüre. SOLID stammt von ihm.
- Eigenes Projekt: nichts schult OOP-Verständnis besser als ein echtes Projekt. Bau dir ein Mini-Bibliotheks-System, Pizza-Bestellsystem o.ä. – aktiv anwenden.
Zusammenfassung
10 IHK-typische OOP-Aufgaben durchgegangen: von EASY (Klassen-Definition, Kapselungs-Definition) bis HARD (Diamond-Problem, SOLID-Verstoß erkennen, UML zu Code übersetzen). Wichtigste Lehren: Vier Säulen (Kapselung, Vererbung, Polymorphismus, Abstraktion) müssen sitzen. SOLID-Buchstaben mit Kurzdefinition. UML lesen und schreiben können. Interface vs. abstrakte Klasse – ein Bewerbungs-Klassiker. Prüfungstipps: Konzepte mit Beispielen verbinden, lieber konkret als abstrakt antworten, bei Code-Aufgaben Schritt für Schritt vorgehen. Übung schlägt Theorie – eigenes Projekt bauen ist der beste Weg.