❓ Fragen & Antworten

✅ Antwort:

Einfache (primitive) Datentypen:

• Speichern den Wert direkt im Speicher
• Haben eine feste Größe im Speicher
• Werden klein geschrieben: int, double, boolean, char, etc.
• Sind keine Objekte und haben keine Methoden
• Es gibt 8 primitive Datentypen in Java

Komplexe (Referenz-) Datentypen:

• Speichern eine Referenz (Adresse) auf ein Objekt im Heap-Speicher
• Können beliebig groß sein
• Werden groß geschrieben: String, Integer, ArrayList, eigene Klassen
• Sind Objekte und haben Methoden und Attribute
• Können null sein (keine Referenz)

✅ Antwort:

✅ Antwort:

Begründung:

• Der Konstruktor wird aufgerufen, um ein neues Objekt zu erstellen und seine Instanzvariablen zu initialisieren
• Er arbeitet mit dem this-Schlüsselwort, das auf die aktuelle Instanz verweist
• Statische Methoden können nicht auf Instanzvariablen zugreifen - der Konstruktor muss das aber tun
• Er hat keinen Rückgabetyp (auch nicht void) und trägt den gleichen Namen wie die Klasse

Warum könnte man denken, er sei statisch?

• Man ruft ihn mit new Klassenname() auf, ohne vorher ein Objekt zu haben
• Das new-Schlüsselwort reserviert aber erst den Speicher, dann wird der Konstruktor auf diesem neuen Objekt ausgeführt

Beispiel:

public class Auto {
    private String marke;
    
    // Konstruktor - NICHT statisch!
    public Auto(String marke) {
        this.marke = marke; // Zugriff auf Instanzvariable
    }
}

✅ Antwort:

✅ Antwort:

Bei der Mehrfachvererbung, bei der eine Klasse von mehreren Oberklassen erbt, können verschiedene schwerwiegende Probleme auftreten. Das bekannteste ist das sogenannte "Diamond-Problem" (Diamant-Problem): Wenn eine Klasse D von zwei Klassen B und C erbt, die beide von einer gemeinsamen Klasse A erben, entsteht eine rautenförmige Vererbungsstruktur. Wenn nun A eine Methode definiert, die sowohl B als auch C unterschiedlich überschreiben, weiß die Klasse D nicht, welche Version der Methode sie verwenden soll.

Zusätzlich können Namenskonflikte bei Attributen entstehen: Wenn beide Oberklassen ein Attribut mit gleichem Namen aber unterschiedlichem Typ oder Bedeutung haben, ist unklar, welches Attribut die Unterklasse erben soll. Dies führt zu Mehrdeutigkeiten und macht den Code schwer verständlich und wartbar.

Die Komplexität des Codes steigt enorm, da der Compiler entscheiden muss, in welcher Reihenfolge die Konstruktoren der Oberklassen aufgerufen werden und wie Methodenaufrufe aufgelöst werden. Dies kann zu unerwartetem Verhalten und schwer zu findenden Fehlern führen.

✅ Antwort:

Das Diamond-Problem entsteht bei Mehrfachvererbung, wenn die Vererbungsstruktur eine Rautenform (Diamant) bildet:

Das Problem:

• A definiert eine Methode foo()
• B überschreibt foo() mit eigenem Verhalten
• C überschreibt foo() ebenfalls anders
• D erbt von B und C - welche Version von foo() soll D haben?

✅ Antwort:

Ein Interface in Java ist ein Vertrag oder eine Schnittstelle, die festlegt, welche Methoden eine Klasse implementieren muss, ohne zu definieren, wie diese implementiert werden. Es ist wie ein Bauplan, der vorschreibt, was eine Klasse können muss.

Hauptmerkmale eines Interfaces:

• Enthält nur abstrakte Methoden (Methodensignaturen ohne Implementierung)
• Alle Methoden sind automatisch public abstract
• Alle Attribute sind automatisch public static final (Konstanten)
• Eine Klasse kann mehrere Interfaces implementieren
• Wird mit dem Schlüsselwort interface deklariert

Warum Interfaces?

• Mehrfachvererbung umgehen: Eine Klasse kann mehrere Interfaces implementieren
• Lose Kopplung: Code ist flexibler und austauschbar
• Polymorphismus: Verschiedene Klassen können gleich behandelt werden
• Vertrag: Garantiert, dass bestimmte Methoden vorhanden sind

Beispiel:

// Interface definieren
public interface Fahrbar {
    void fahren();
    void bremsen();
}

// Interface implementieren
public class Auto implements Fahrbar {
    public void fahren() {
        System.out.println("Auto fährt");
    }
    
    public void bremsen() {
        System.out.println("Auto bremst");
    }
}

✅ Antwort:

✅ Antwort:

Überladen (Overloading):

• Mehrere Methoden mit gleichem Namen aber unterschiedlichen Parametern
• Findet in derselben Klasse statt
• Wird zur Compile-Zeit aufgelöst (statische Bindung)
• Rückgabetyp kann unterschiedlich sein

// Überladen - gleiche Klasse, verschiedene Parameter
public int addiere(int a, int b) { ... }
public double addiere(double a, double b) { ... }
public int addiere(int a, int b, int c) { ... }

Überschreiben (Overriding):

• Methode der Oberklasse wird in Unterklasse neu definiert
• Findet in einer Vererbungsbeziehung statt
• Wird zur Laufzeit aufgelöst (dynamische Bindung)
• Signatur muss exakt gleich sein

// Überschreiben - Unterklasse definiert Methode neu
class Tier {
    public void sprechen() { 
        System.out.println("..."); 
    }
}

class Hund extends Tier {
    @Override
    public void sprechen() { 
        System.out.println("Wuff!"); 
    }
}

✅ Antwort:

Definition: Kapselung bedeutet, die Attribute einer Klasse zu verbergen (private) und den Zugriff nur über öffentliche Methoden (Getter/Setter) zu erlauben.

Vorteile der Kapselung:

• Datenschutz: Interne Daten sind vor direktem Zugriff geschützt
• Validierung: In Settern kann geprüft werden, ob Werte gültig sind
• Flexibilität: Interne Implementierung kann geändert werden, ohne externen Code zu brechen
• Wartbarkeit: Fehler sind leichter zu finden und zu beheben

public class Bankkonto {
    private double kontostand; // versteckt
    
    // Getter - kontrollierter Lesezugriff
    public double getKontostand() {
        return kontostand;
    }
    
    // Setter mit Validierung
    public void einzahlen(double betrag) {
        if (betrag > 0) {
            kontostand += betrag;
        }
    }
}

✅ Antwort:

Definition: Polymorphismus (griech. "Vielgestaltigkeit") bedeutet, dass Objekte verschiedener Klassen über dieselbe Schnittstelle angesprochen werden können, aber unterschiedlich reagieren.

Arten von Polymorphismus:

1. Statischer Polymorphismus (Compile-Zeit):

• Durch Methodenüberladung (Overloading)
• Compiler entscheidet anhand der Parameter, welche Methode aufgerufen wird

2. Dynamischer Polymorphismus (Laufzeit):

• Durch Methodenüberschreiben (Overriding)
• Zur Laufzeit wird entschieden, welche Methode aufgerufen wird

Tier[] tiere = new Tier[3];
tiere[0] = new Hund();
tiere[1] = new Katze();
tiere[2] = new Vogel();

// Alle als "Tier" behandelt, aber jedes spricht anders
for (Tier t : tiere) {
    t.sprechen(); // Wuff! Miau! Piep!
}

✅ Antwort:

public class Auto {
    static int anzahlAutos = 0;  // Für alle gleich
    String farbe;                // Jedes Auto hat eigene
    
    public Auto(String farbe) {
        this.farbe = farbe;
        anzahlAutos++;           // Zählt alle Autos
    }
    
    static int getAnzahl() {      // Ohne Objekt aufrufbar
        return anzahlAutos;
    }
}

✅ Antwort:

Kurzbeschreibung:

• public: Von überall sichtbar
• protected: Im Package und in Unterklassen sichtbar
• default (kein Modifier): Nur im gleichen Package sichtbar
• private: Nur in der eigenen Klasse sichtbar

✅ Fachsprachliche Beschreibung:

Es wird eine öffentliche Klasse namens Fahrzeug definiert. Die Klasse besitzt zwei private Instanzvariablen (Attribute): marke vom Datentyp String und baujahr vom primitiven Datentyp int.

Die Klasse verfügt über einen parametrisierten Konstruktor, der zwei Parameter entgegennimmt: einen String marke und einen Integer baujahr. Im Konstruktor werden die übergebenen Parameterwerte den Instanzvariablen zugewiesen. Das Schlüsselwort this wird verwendet, um die Instanzvariablen von den gleichnamigen Parametern zu unterscheiden.

Durch die Kapselung (private Attribute) sind die Daten von außen nicht direkt zugänglich.

✅ Fachsprachliche Beschreibung:

Es wird eine öffentliche Klasse Hund definiert, die von der Klasse Tier erbt (Schlüsselwort extends). Die Klasse Hund ist somit eine Unterklasse (Subklasse) von Tier.

Die Klasse besitzt ein privates Attribut rasse vom Typ String. Der Konstruktor nimmt zwei Parameter entgegen: name und rasse. Mit dem Schlüsselwort super wird der Konstruktor der Oberklasse aufgerufen und der Parameter name an diesen übergeben.

Die Methode sprechen() überschreibt (Override) eine gleichnamige Methode der Oberklasse Tier. Die Annotation @Override macht dies explizit deutlich. Die Methode gibt den Text "Wuff!" auf der Konsole aus. Dies ist ein Beispiel für Polymorphismus.

✅ Fachsprachliche Beschreibung:

Es wird ein öffentliches Interface namens Fahrbar definiert. Ein Interface ist eine Schnittstelle, die einen Vertrag für Klassen festlegt, welche Methoden diese implementieren müssen.

Das Interface deklariert drei abstrakte Methoden:

• fahren() – eine Methode ohne Rückgabewert (void)
• bremsen() – ebenfalls ohne Rückgabewert
• getGeschwindigkeit() – eine Methode mit Rückgabetyp int

Alle Methoden in einem Interface sind implizit public abstract. Jede Klasse, die dieses Interface implementiert, muss alle drei Methoden mit konkretem Code versehen.

✅ Fachsprachliche Beschreibung:

Es wird eine öffentliche Klasse Konto definiert. Die Klasse besitzt ein privates Attribut kontostand vom Datentyp double für Gleitkommazahlen.

Die Methode getKontostand() ist ein Getter (Zugriffsmethode), der den aktuellen Wert des Attributs kontostand zurückgibt. Der Rückgabetyp ist double.

Die Methode setKontostand() ist ein Setter (Änderungsmethode) mit dem Parameter betrag. Die Methode enthält eine Validierung: Nur wenn der übergebene Betrag größer oder gleich 0 ist, wird der Kontostand aktualisiert. Dies verhindert negative Kontostände.

Dieses Muster demonstriert das OOP-Prinzip der Kapselung (Encapsulation): Die Daten sind geschützt und der Zugriff erfolgt kontrolliert über Getter und Setter.

✅ Fachsprachliche Beschreibung:

Es wird eine abstrakte Klasse namens Figur definiert (Schlüsselwort abstract). Von einer abstrakten Klasse können keine Objekte direkt instanziiert werden.

Die Klasse besitzt ein protected Attribut farbe vom Typ String. Der Sichtbarkeitsmodifizierer protected bedeutet, dass das Attribut in der Klasse selbst, im selben Package und in allen Unterklassen sichtbar ist.

Der Konstruktor initialisiert das Attribut farbe mit dem übergebenen Parameter.

Die Methode berechneFlaeche() ist eine abstrakte Methode: Sie hat nur eine Signatur, aber keine Implementierung (keinen Methodenrumpf). Jede konkrete Unterklasse muss diese Methode implementieren und einen double-Wert zurückgeben.

✅ Fachsprachliche Beschreibung:

Es wird eine öffentliche Klasse Zaehler definiert. Die Klasse besitzt zwei Attribute:

• anzahl – ein statisches (Klassen-) Attribut vom Typ int, initialisiert mit 0. Statische Attribute existieren nur einmal pro Klasse und werden von allen Objekten geteilt.
• id – ein Instanzattribut vom Typ int, das für jedes Objekt individuell ist.

Der parameterlose Konstruktor (Default-Konstruktor) erhöht bei jedem Aufruf die statische Variable anzahl um 1 und weist diesen Wert dem Instanzattribut id zu. So erhält jedes neue Objekt eine eindeutige ID.

Die statische Methode getAnzahl() kann ohne Objekt über den Klassennamen aufgerufen werden (Zaehler.getAnzahl()) und gibt die Gesamtanzahl der erzeugten Objekte zurück.

✅ Fachsprachliche Beschreibung:

Es wird eine öffentliche Klasse Auto definiert, die zwei Interfaces implementiert: Fahrbar und Serializable (Schlüsselwort implements). Dies zeigt, dass Java zwar keine Mehrfachvererbung bei Klassen erlaubt, aber eine Klasse mehrere Interfaces implementieren kann.

Die Klasse hat zwei private Attribute: marke (String) und geschwindigkeit (int).

Die Methoden fahren() und bremsen() sind mit @Override annotiert, was zeigt, dass sie Methoden aus dem Interface Fahrbar implementieren:

• fahren() setzt die Geschwindigkeit auf 50
• bremsen() setzt die Geschwindigkeit auf 0

Die Klasse erfüllt damit den Vertrag des Interfaces und stellt die geforderte Funktionalität bereit.

✅ Wahrheitstabelle:

📝 Erklärung:

• ∧ (UND/AND): Nur wahr wenn BEIDE Operanden wahr sind
• ∨ (ODER/OR): Wahr wenn MINDESTENS EINER wahr ist
• ¬ (NICHT/NOT): Negiert den Wert (0→1, 1→0)

Der Ausdruck ist wahr (=1) wenn entweder ¬C = 1 (also C=0) ODER wenn D∧(A∧B) = 1 (also A, B und D alle =1).

✅ Wahrheitstabelle mit allen Zwischenergebnissen:

Hinweis: Implikation A → B = ¬A ∨ B (nur falsch wenn A=1 und B=0)

📝 Implikation (→) Wahrheitstabelle:

Merke: P → Q ist nur FALSCH wenn P wahr und Q falsch ist!

✅ KV-Diagramm (4 Variablen A, B, C, D):

📝 Gruppenbildung:

• Gruppe (grün): Alle 8 Einsen in den Spalten AB und AB → das bedeutet A=1

Minimiert: Y = A

⚠️ KV-Diagramm Regeln:

• Gruppen müssen 2ⁿ Zellen haben (1, 2, 4, 8, 16...)
• Gruppen müssen rechteckig sein
• Gruppen können an den Rändern "wrappen"
• Jede 1 muss in mindestens einer Gruppe sein
• Größtmögliche Gruppen bilden!

✅ DNF (Disjunktive Normalform):

DNF = ODER-Verknüpfung der Minterme (Zeilen mit Y=1):

• Zeile 2 (A=0, B=0, C=1): ¬A ∧ ¬B ∧ C
• Zeile 4 (A=0, B=1, C=1): ¬A ∧ B ∧ C
• Zeile 6 (A=1, B=0, C=1): A ∧ ¬B ∧ C
• Zeile 7 (A=1, B=1, C=0): A ∧ B ∧ ¬C
• Zeile 8 (A=1, B=1, C=1): A ∧ B ∧ C

DNF: Y = (¬A ∧ ¬B ∧ C) ∨ (¬A ∧ B ∧ C) ∨ (A ∧ ¬B ∧ C) ∨ (A ∧ B ∧ ¬C) ∨ (A ∧ B ∧ C)

✅ KNF (Konjunktive Normalform):

KNF = UND-Verknüpfung der Maxterme (Zeilen mit Y=0, Variablen umgekehrt!):

• Zeile 1 (A=0, B=0, C=0): 0→A, 0→B, 0→C → A ∨ B ∨ C
• Zeile 3 (A=0, B=1, C=0): 0→A, 1→¬B, 0→C → A ∨ ¬B ∨ C
• Zeile 5 (A=1, B=0, C=0): 1→¬A, 0→B, 0→C → ¬A ∨ B ∨ C

KNF: Y = (A ∨ B ∨ C) ∧ (A ∨ ¬B ∨ C) ∧ (¬A ∨ B ∨ C)

📝 Merkhilfe:

• DNF: Y=1 Zeilen → Variable normal übernehmen (1→A, 0→¬A)
• KNF: Y=0 Zeilen → Variable umgekehrt übernehmen (1→¬A, 0→A)

Minimiert (mit KV-Diagramm): Y = C ∨ (A ∧ B)

✅ Wahrheitstabellen aller Gatter:

📝 Merkhilfen:

• AND (&): "Beide müssen 1 sein" → nur 1∧1=1
• OR (≥1): "Mindestens einer muss 1 sein" → nur 0∨0=0
• XOR (=1): "Genau einer muss 1 sein" → unterschiedlich = 1
• NAND/NOR/XNOR: Negiertes Ergebnis des Basis-Gatters (○ am Ausgang)

⚡ Wichtig für die Klausur:

• NAND ist ein "universelles Gatter" - man kann alle anderen Gatter daraus bauen!
• NOR ist ebenfalls ein universelles Gatter.
• Der Kreis (○) am Ausgang bedeutet immer Negation.

✅ Analyse:

Der Algorithmus berechnet die Fakultät einer Zahl (n! = 1 × 2 × 3 × ... × n).

Java-Code:

int zahl = 5; // Eingabe
int ergebnis = 1;
int i = 1;

while (i <= zahl) {
    ergebnis = ergebnis * i;
    i = i + 1;
}

System.out.println(ergebnis); // Ausgabe: 120

Trace für zahl=5:

✅ Analyse:

Der Algorithmus findet das Maximum von zwei Zahlen.

Java-Code:

int a = 7;
int b = 12;
int max;

if (a > b) {
    max = a;
} else {
    max = b;
}

System.out.println("Maximum: " + max);

Alternative mit Ternär-Operator:

int max = (a > b) ? a : b;

✅ Struktogramm:

📝 Beschreibung:

Der Algorithmus berechnet die Summe aller positiven Zahlen in einem Array. Negative Zahlen und Null werden ignoriert.