# Generische Klassen

### Definition

Eine generische Klasse in Java ist eine Klasse, die mit **Typparametern** arbeitet, anstatt mit festen Datentypen.
Sie ermöglicht es, denselben Code für verschiedene Datentypen zu verwenden, ohne dabei die Typsicherheit zu verlieren.


> Eine generische Klasse ist eine Klasse, die einen oder mehrere Platzhalter (`<T>`) für Datentypen verwendet, damit sie mit unterschiedlichen Typen arbeiten kann, ohne dass Typumwandlungen nötig sind.

---

### Beispiel

```java
public class Box<T> {
    private T inhalt;

    public void setInhalt(T inhalt) {
        this.inhalt = inhalt;
    }

    public T getInhalt() {
        return inhalt;
    }
}
```

→ `T` ist ein Typparameter, der beim Erzeugen des Objekts durch einen konkreten Typ ersetzt wird:

```java
Box<String> textBox = new Box<>();
Box<Integer> zahlenBox = new Box<>();
```

---

### Kurz erklärt

* `<T>` steht für einen beliebigen Datentyp.
* Der Compiler sorgt dafür, dass nur dieser Typ verwendet werden darf.
* Dadurch entsteht typsicherer, wiederverwendbarer und flexibler Code.

### <T> extends Class

Es ist nicht selten der Fall, dass die Typparameter einer generischen Klasse zwingend einer bestimmten Superklasse angehören müssen, um ungeeignete Datentypen zu vermeiden. So ist es sinnvoll, beispielsweise die Variablen eines Rechners nur mit numerischen Typen zu initialisieren. Dies kann durch Erweiterungsangaben der Typparameter erfolgen:

```java
class NumberBox<T extends Number> {
    private T value;

    public NumberBox(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public double getDoubleValue() {
        return value.doubleValue(); // Number-Methode
    }

    public static void main(String[] args) {
        NumberBox<Integer> intBox = new NumberBox<>(42);
        System.out.println(intBox.getDoubleValue()); // 42.0

        NumberBox<Double> doubleBox = new NumberBox<>(3.14);
        System.out.println(doubleBox.getDoubleValue()); // 3.14

        // Das würde einen Compiler-Fehler geben:
        // NumberBox<String> stringBox = new NumberBox<>("Hallo");

    }
}
```


| Klasse/Interface         | Typische Subklassen/Implementierungen         | Beispiel für generische Einschränkung         |
|--------------------------|-----------------------------------------------|-----------------------------------------------|
| `Number`                 | `Integer`, `Double`, `Float`, `Long`, `Short` | `<T extends Number>`                          |
| `Comparable<T>`          | `String`, `Integer`, `Double`, `LocalDate`    | `<T extends Comparable<T>>`                   |
| `CharSequence`           | `String`, `StringBuilder`, `StringBuffer`    | `<T extends CharSequence>`                    |
| `Collection<E>`          | `List<E>`, `Set<E>`, `Queue<E>`               | `<T extends Collection<String>>`              |
| `List<E>`                | `ArrayList<E>`, `LinkedList<E>`               | `<T extends List<Integer>>`                   |
| `Map<K, V>`              | `HashMap<K, V>`, `TreeMap<K, V>`              | `<T extends Map<String, Integer>>`            |
| `AutoCloseable`          | `InputStream`, `OutputStream`, `Scanner`      | `<T extends AutoCloseable>`                   |
| `Runnable`               | (funktionales Interface)                      | `<T extends Runnable>`                        |
| `Iterable<E>`            | `Collection<E>`, `List<E>`, `Set<E>`           | `<T extends Iterable<String>>`                |
| `Object`                 | **Jede Klasse** (oberste Klasse in Java)      | `<T extends Object>` (selten nötig)           |
| `Enum<E>`                | Alle Aufzählungstypen (z.B. `Day`, `Color`)   | `<T extends Enum<T>>`                         |