Was sind Generics (Generische Typen) in der…

Generics sind ein Mechanismus in Programmiersprachen, der es ermöglicht, Komponenten (Klassen, Schnittstellen, Methoden/Funktionen) zu erstellen, die mit verschiedenen Datentypen arbeiten, ohne die Typsicherheit zu verlieren und ohne Typumwandlungen (Casting) vorzunehmen.

Hauptziele der Verwendung von Generics:

Erhöhung der Typsicherheit: Der Compiler überprüft die Typen zur Compile-Zeit und erkennt Fehler vor der Ausführung des Programms.
Verbesserung der Lesbarkeit des Codes: Es ist klar ersichtlich, mit welchen Datentypen eine Komponente arbeitet.
Wiederverwendung von Code: Es kann eine einzige Komponente erstellt werden, die mit verschiedenen Typen funktioniert, anstatt mehrere Versionen zu schreiben.
Reduzierung von Typumwandlungen: Vermeidet die Notwendigkeit expliziter Casts, was den Code sauberer und weniger fehleranfällig macht ClassCastException (in Sprachen, in denen dies zutrifft, z.B. Java).

Beispiele für die Verwendung von Generics:

Sammlungen: Listen (List), Mengen (Set), Karten (Map) können Elemente eines bestimmten Typs speichern, was garantiert, dass keine Elemente eines anderen Typs eingefügt werden.
Methoden/Funktionen: Eine Methode kann mit Parametern arbeiten oder einen Wert eines universellen Typs zurückgeben.
Klassen/Schnittstellen: Es können universelle Datenstrukturen oder Verhaltensmuster erstellt werden.

Beispiel in Java:

// Generische Klasse Pair
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

// Verwendung
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Es ist kein Cast erforderlich
int num = pair.getSecond();   // Es ist kein Cast erforderlich

// Falsches Pair-Beispiel
// Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Kompilierungsfehler: Typinkompatibilität

Beispiel in C#:

// Generische Klasse Pair
public class Pair<T, U>
{
    public T First { get; set; }
    public U Second { get; set; }

    public Pair(T first, U second)
    {
        First = first;
        Second = second;
    }
}

// Verwendung
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Es ist kein Cast erforderlich
int num = pair.Second;   // Es ist kein Cast erforderlich

// Falsches Pair-Beispiel
// var wrongPair = new Pair<string, int>(123, "Hello"); // Kompilierungsfehler: Typinkompatibilität

Beispiel in TypeScript:

// Generische Funktion zum Erhalten des ersten Elements eines Arrays
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Verwendung
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber hat den Typ number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord hat den Typ string

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed hat den Typ number | string

Generics sind also ein mächtiges Werkzeug, um flexible, typsichere und wiederverwendbare Codes zu erstellen.

Was sind Generics (Generische Typen) in der Programmierung?