Wann verwendet man in Java ein Interface und wann eine abstrakte Klasse? Je 5 Beispiele.

In Java werden Interfaces und abstrakte Klassen für unterschiedliche Zwecke eingesetzt. Hier die wichtigsten Unterschiede und typische Anwendungsfälle:

**Interface:**
- Wird verwendet, um eine Schnittstelle zu definieren, die von beliebigen Klassen implementiert werden kann, unabhängig von deren Platz in der Klassenhierarchie.
- Mehrfachvererbung ist möglich (eine Klasse kann mehrere Interfaces implementieren).
- Enthält nur Methodensignaturen (ab Java 8 auch default/static-Methoden, aber keine Zustände/Instanzvariablen außer `static final`).

**Abstrakte Klasse:**
- Wird verwendet, um eine gemeinsame Basisklasse mit (ggf. teilweiser) Implementierung zu schaffen.
- Kann sowohl abstrakte als auch konkrete Methoden enthalten.
- Kann Felder (Instanzvariablen) und Konstruktoren besitzen.
- Nur Einfachvererbung möglich (eine Klasse kann nur von einer abstrakten Klasse erben).

---

### 5 Beispiele für den Einsatz eines **Interface**:

1. **Vergleichbarkeit**:
```java
public interface Comparable<T> {
int compareTo(T o);
}
```
Wird von Klassen wie `String`, `Integer` usw. implementiert.

2. **Ereignisbehandlung (Listener)**:
```java
public interface ActionListener {
void actionPerformed(ActionEvent e);
}
```
Wird von GUI-Komponenten verwendet.

3. **Datenübertragung (Serializable)**:
```java
public interface Serializable {}
```
Markiert Objekte, die serialisiert werden können.

4. **Funktionale Schnittstellen (z.B. Runnable)**:
```java
public interface Runnable {
void run();
}
```
Für Threads und parallele Ausführung.

5. **Sammlungen (z.B. List, Set, Map)**:
```java
public interface List<E> extends Collection<E> { ... }
```
Wird von ArrayList, LinkedList usw. implementiert.

---

### 5 Beispiele für den Einsatz einer **abstrakten Klasse**:

1. **Basisklasse für Tiere**:
```java
public abstract class Animal {
public abstract void makeSound();
public void eat() { System.out.println("Animal is eating"); }
}
```
Gemeinsame Funktionalität für verschiedene Tierarten.

2. **Abstrakte GUI-Komponente**:
```java
public abstract class Component {
public abstract void draw();
public void move(int x, int y) { ... }
}
```
Basisklasse für verschiedene GUI-Elemente.

3. **Abstrakte Datenbankverbindung**:
```java
public abstract class DatabaseConnection {
public abstract void connect();
public void disconnect() { ... }
}
```
Gemeinsame Methoden für verschiedene Datenbanktypen.

4. **Abstrakte Fahrzeugklasse**:
```java
public abstract class Vehicle {
public abstract void drive();
public void refuel() { ... }
}
```
Für Autos, Motorräder, LKWs usw.

5. **Abstrakte Dokumentklasse**:
```java
public abstract class Document {
public abstract void print();
public void save() { ... }
}
```
Für verschiedene Dokumenttypen wie PDF, Word, etc.

---

**Zusammenfassung:**
- **Interface**: Wenn du eine reine Schnittstelle ohne Implementierung und ohne Zustände brauchst, die von vielen, auch nicht verwandten Klassen implementiert werden soll.
- **Abstrakte Klasse**: Wenn du eine gemeinsame Basisklasse mit (teilweiser) Implementierung und gemeinsamen Feldern brauchst, von der spezialisierte Klassen erben sollen.