Lösungen

Aufgabe 1 – Grundlagen von Klassen und Objekten

1. Unterschied zwischen Klasse und Objekt

Eine Klasse ist der Bauplan für Objekte.
Ein Objekt ist ein konkretes Exemplar dieser Klasse im Arbeitsspeicher.

Beispiel:

// Klasse
public class Hund { String name; int alter; }

// Objekt
Hund h1 = new Hund(); // erstellt ein konkretes Objekt

2. Was passiert im Speicher bei

Hund h1 = new Hund();
h1.name = "Ava";
h1.alter = 4;

new Hund() erzeugt im Speicher ein neues Objekt der Klasse Hund.
h1 ist eine Referenzvariable, die auf dieses Objekt zeigt.
Anschließend werden die Attribute name und alter des Objekts befüllt.

3. Was ist eine Methode?

Eine Methode ist eine Funktion innerhalb einer Klasse.
Sie beschreibt ein Verhalten eines Objekts (z. B. bellen(), laufen(), info()).

4. Warum new?

Ohne new existiert kein Objekt im Speicher.
Erst new sorgt dafür, dass der Bauplan (Klasse) zu einer realen Instanz wird.

Aufgabe 2 – Konstruktoren und `this`

1. Parametrisierter Konstruktor

public class Auto {
    String marke;
    int baujahr;

    public Auto(String marke, int baujahr) {
        this.marke = marke;
        this.baujahr = baujahr;
    }
}

2. Warum this.name = name;?

Weil sonst der Parameter name das gleichnamige Attribut überdeckt.
Mit this.name wird das Attribut der Klasse angesprochen, nicht der Parameter.

3. Unterschied:

this.name = name; // weist dem Attribut den Parameter zu
name = name;      // tut gar nichts – Parameter wird sich selbst zugewiesen

4. Mehrere Konstruktoren ohne Code-Dopplung

Mit Konstruktorverkettung:

public class Hund {
    String name;
    int alter;

    public Hund() {
        this("Unbekannt", 0); // ruft den anderen Konstruktor auf
    }

    public Hund(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }
}

5. Was passiert bei

public Hund() {
    this("Unbekannt", 0);
}

→ Der parameterlose Konstruktor ruft den zweiten Konstruktor mit Standardwerten auf.

Aufgabe 3 – Kapselung und Zugriffskontrolle

1. Unterschied public / private

public: von überall sichtbar.
private: nur innerhalb derselben Klasse sichtbar.

2. Warum private Felder?

Damit niemand unkontrolliert Werte verändern kann (z. B. negatives Alter oder falscher Kontostand).
Nur die Klasse selbst entscheidet, wie Daten geändert werden dürfen.

3. Getter und Setter mit Schutzlogik

public class Konto {
    private double kontostand;

    public double getKontostand() {
        return kontostand;
    }

    public void setKontostand(double betrag) {
        if (betrag >= 0) {
            kontostand = betrag;
        } else {
            System.out.println("Fehler: negativer Kontostand nicht erlaubt!");
        }
    }
}

4. Fachbegriff:

Kapselung (Encapsulation)

5. Zugriff auf private Attribut

Konto k = new Konto();
k.kontostand = 100; // X Compilerfehler: kontostand hat private Zugriff

→ Nur über Setter/Getter erlaubt.

Aufgabe 4 – Vererbung und Polymorphie

1. Bedeutung von extends

extends bedeutet: Klasse B erbt von Klasse A.
Alle Attribute und Methoden von A sind auch in B verfügbar.

class Tier {
    void laut() { System.out.println("Tier macht Geräusch."); }
}
class Hund extends Tier {
    void laut() { System.out.println("Hund bellt."); }
}
public class Main {
    public static void main(String[] args) {
        Tier t = new Hund();
        t.laut();
    }
}

Ausgabe:

Hund bellt.

Begründung:
Zur Laufzeit wird die Methode der tatsächlichen Objektklasse (Hund) ausgeführt → Polymorphie.

3. Unterschied Override vs Overload

Begriff	Beschreibung	Beispiel
Überladen (overload)	gleiche Methodenname, andere Parameter	`void setName(String)` / `void setName(String,int)`
Überschreiben (override)	gleiche Signatur in Unterklasse	`@Override void essen()`

4. Reihenfolge der Konstruktoren

Beim Erzeugen einer Unterklasse wird zuerst der Eltern-Konstruktor,
dann der eigene Konstruktor ausgeführt.

class Tier { Tier(){System.out.println("Tier erzeugt.");} }
class Hund extends Tier { Hund(){System.out.println("Hund erzeugt.");} }

Ausgabe:

Tier erzeugt.
Hund erzeugt.

5. Bedeutung von super.essen()

Ruft die ursprüngliche Methode der Elternklasse auf,
bevor (oder nachdem) der eigene Code läuft.

Aufgabe 5 – Fehlerbehandlung mit Exceptions

1. Was passiert ohne Behandlung?

→ Programmabbruch mit Fehlermeldung („Stacktrace“).
Das Programm stoppt an der fehlerhaften Stelle.

2. Bedeutung von try, catch, finally

try: enthält Code, der fehlschlagen kann
catch: behandelt den Fehler
finally: wird immer ausgeführt, z. B. zum Aufräumen

3. Checked vs. Unchecked

Typ	Beschreibung	Beispiel
Checked	vom Compiler überprüft, muss behandelt werden	`IOException`, `SQLException`
Unchecked	Laufzeitfehler, optional zu behandeln	`NullPointerException`, `ArithmeticException`

4. Vervollständigung

try {
    int ergebnis = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Division durch 0!");
}

5. Eigene Exception

public class ZuWenigGuthabenException extends Exception {
    public ZuWenigGuthabenException(String msg) { super(msg); }
}

public class Konto {
    private double kontostand = 100.0;

    public void abheben(double betrag) throws ZuWenigGuthabenException {
        if (betrag > kontostand) {
            throw new ZuWenigGuthabenException("Zu wenig Guthaben: " + kontostand);
        }
        kontostand -= betrag;
    }
}

Verwendung:

try {
    Konto k = new Konto();
    k.abheben(200);
} catch (ZuWenigGuthabenException e) {
    System.out.println("Fehler: " + e.getMessage());
}

Aufgabe 6 – Mini-Projekt (Vererbung + Methodenüberschreibung)

1. Oberklasse:

public class Fahrzeug {
    private String marke;
    private int geschwindigkeit;

    public Fahrzeug(String marke, int geschwindigkeit) {
        this.marke = marke;
        this.geschwindigkeit = geschwindigkeit;
    }

    public void beschleunigen(int wert) {
        if (wert > 0) {
            geschwindigkeit += wert;
            System.out.println(marke + " fährt jetzt " + geschwindigkeit + " km/h.");
        }
    }

    public String getMarke() { return marke; }
    public int getGeschwindigkeit() { return geschwindigkeit; }
}

2. Unterklasse Auto:

public class Auto extends Fahrzeug {
    public Auto(String marke, int geschwindigkeit) {
        super(marke, geschwindigkeit);
    }

    @Override
    public void beschleunigen(int wert) {
        super.beschleunigen(wert);
        System.out.println("Motor brummt!");
    }
}

3. Unterklasse Fahrrad:

public class Fahrrad extends Fahrzeug {
    public Fahrrad(String marke, int geschwindigkeit) {
        super(marke, geschwindigkeit);
    }

    @Override
    public void beschleunigen(int wert) {
        super.beschleunigen(wert);
        System.out.println("Tritt in die Pedale!");
    }
}

4. Main-Klasse:

public class Main {
    public static void main(String[] args) {
        Auto a = new Auto("BMW", 50);
        Fahrrad f = new Fahrrad("Cube", 10);

        a.beschleunigen(30);
        f.beschleunigen(5);
    }
}

Ausgabe:

BMW fährt jetzt 80 km/h.
Motor brummt!
Cube fährt jetzt 15 km/h.
Tritt in die Pedale!

Lösungen

Aufgabe 1 – Grundlagen von Klassen und Objekten

Aufgabe 2 – Konstruktoren und this

Aufgabe 3 – Kapselung und Zugriffskontrolle

Aufgabe 4 – Vererbung und Polymorphie

Aufgabe 5 – Fehlerbehandlung mit Exceptions

Aufgabe 6 – Mini-Projekt (Vererbung + Methodenüberschreibung)

Anmelden

Account Registrieren und Fortschritt Speichern!

Modal title

Aufgabe 2 – Konstruktoren und `this`