Generische Klassen: Generics, Type Safety & Type Parameters

Dieser Beitrag ist eine umfassende Erläuterung der generischen Klassen – inklusive Generics, Type Safety, Wildcards und Bounded Type Parameters mit praktischen Beispielen.

In a Nutshell

Generische Klassen sind Typ-Schablonen, die durch Type-Parameter wiederverwendbare, typsichere Datenstrukturen und Algorithmen bereitstellen. Beispiele sind List<T>, Map<K,V> oder C++ Templates.

Kompakte Fachbeschreibung

Generische Klassen kapseln Verhalten unabhängig vom konkreten Datentyp und werden durch Typ-Argumente instanziiert. Sie ermöglichen typsichere Wiederverwendung ohne Code-Duplizierung.

Implementierung in verschiedenen Sprachen:

Java Generics

Type Erasure: Typinformationen werden zur Kompilierzeit entfernt
Laufzeit: Nur Raw Types, keine generischen Typen
Wildcards: ? extends Number, ? super Number
Bounded Types: <T extends Number>

C# Generics

Reified Generics: Typinformationen bleiben zur Laufzeit erhalten
Constraints: where T : class, new()
Covariance/Kontravariance: out T, in T
Performance: Keine Box-Unbox Overhead

C++ Templates

Compile-Time: Für jeden Typ wird spezialisierte Version generiert
Zero Cost: Kein Runtime-Overhead
Template Metaprogramming: Turing-vollständig
SFINAE: Substitution Failure Is Not An Error

Zentrale Konzepte:

Invarianz: List<String> ist kein List<Object>
Covarianz: Producer extends (kann liefern)
Kontravarianz: Consumer super (kann verbrauchen)

Prüfungsrelevante Stichpunkte

Generics: Typ-Schablonen für wiederverwendbaren Code
Type Safety: Kompilierzeit-Typprüfung statt Runtime-Fehler
Type Parameters: Platzhalter für konkrete Typen
Bounded Types: Einschränkungen für Type-Parameter
Wildcards: Unbekannte Typen mit Einschränkungen
Type Erasure: Java-Implementierung ohne Runtime-Typen
PECS Regel: Producer Extends, Consumer Super
IHK-relevant: Wichtig für typsichere Programmierung

Kernkomponenten

Type Parameter: Platzhalter <T> für konkrete Typen
Bounded Types: <T extends Number> mit Einschränkungen
Wildcards: <?> für unbekannte Typen
Generic Methods: <T> T max(T a, T b)
Generic Classes: class Box<T>
Type Safety: Kompilierzeit-Typprüfung
Covariance: Producer extends Beziehung
Kontravarianz: Consumer super Beziehung

Praxisbeispiele

1. Einfache generische Klasse in Java

// Generische Box-Klasse
public class Box<T> {
    private T inhalt;
    
    public Box() {
        this.inhalt = null;
    }
    
    public Box(T inhalt) {
        this.inhalt = inhalt;
    }
    
    public void setInhalt(T inhalt) {
        this.inhalt = inhalt;
    }
    
    public T getInhalt() {
        return inhalt;
    }
    
    public boolean istLeer() {
        return inhalt == null;
    }
    
    @Override
    public String toString() {
        return "Box[" + (inhalt != null ? inhalt.toString() : "leer") + "]";
    }
}

// Verwendung der generischen Klasse
public class BoxDemo {
    public static void main(String[] args) {
        // Box für Strings
        Box<String> stringBox = new Box<>("Hallo Welt");
        System.out.println(stringBox); // Box[Hallo Welt]
        
        // Box für Integer
        Box<Integer> integerBox = new Box<>(42);
        System.out.println(integerBox); // Box[42]
        
        // Box für eigene Objekte
        class Person {
            String name;
            Person(String name) { this.name = name; }
            @Override public String toString() { return name; }
        }
        
        Box<Person> personBox = new Box<>(new Person("Max"));
        System.out.println(personBox); // Box[Max]
        
        // Type Safety zur Kompilierzeit
        // stringBox.setInhalt(123); // Fehler: kann nicht Integer zu String zuweisen
    }
}

2. Generische Methoden

public class GenericMethods {
    
    // Generische Methode zum Tauschen
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    
    // Generische Methode mit Bounded Type Parameter
    public static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }
    
    // Generische Methode mit Wildcard
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    
    // PECS: Producer Extends
    public static double sum(List<? extends Number> list) {
        double sum = 0.0;
        for (Number n : list) {
            sum += n.doubleValue();
        }
        return sum;
    }
    
    // PECS: Consumer Super
    public static void addNumbers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }
    
    public static void main(String[] args) {
        // Swap-Methode
        String[] names = {"Alice", "Bob", "Charlie"};
        swap(names, 0, 2);
        System.out.println(Arrays.toString(names)); // [Charlie, Bob, Alice]
        
        // Max-Methode
        System.out.println(max(5, 10)); // 10
        System.out.println(max("Apple", "Banana")); // Banana
        
        // Wildcard
        List<String> strings = Arrays.asList("A", "B", "C");
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        
        printList(strings); // A B C
        printList(numbers); // 1 2 3
        
        // PECS Beispiele
        List<Integer> ints = Arrays.asList(1, 2, 3);
        System.out.println(sum(ints)); // 6.0
        
        List<Object> objects = new ArrayList<>();
        addNumbers(objects);
        System.out.println(objects); // [1, 2, 3]
    }
}

3. Generische Klasse mit Bounded Types

// Generische Klasse mit mehreren Bounded Type Parameters
public class Paar<T extends Comparable<T>, U> {
    private T erster;
    private U zweiter;
    
    public Paar(T erster, U zweiter) {
        this.erster = erster;
        this.zweiter = zweiter;
    }
    
    public T getErster() {
        return erster;
    }
    
    public U getZweiter() {
        return zweiter;
    }
    
    public void setErster(T erster) {
        this.erster = erster;
    }
    
    public void setZweiter(U zweiter) {
        this.zweiter = zweiter;
    }
    
    // Methode die von Bounded Type profitiert
    public int vergleicheErsten(T anderer) {
        return this.erster.compareTo(anderer);
    }
    
    @Override
    public String toString() {
        return "Paar[" + erster + ", " + zweiter + "]";
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Paar<T, U> paar = (Paar<T, U>) obj;
        return erster.equals(paar.erster) && zweiter.equals(paar.zweiter);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(erster, zweiter);
    }
}

// Verwendung
public class PaarDemo {
    public static void main(String[] args) {
        // Gültig: String implements Comparable
        Paar<String, Integer> nameAlter = new Paar<>("Alice", 25);
        System.out.println(nameAlter); // Paar[Alice, 25]
        
        // Fehler: StringBuilder implements nicht Comparable
        // Paar<StringBuilder, Integer> invalid = new Paar<>(new StringBuilder(), 25);
        
        // Vergleich nutzen
        Paar<String, Integer> alice = new Paar<>("Alice", 25);
        Paar<String, Integer> bob = new Paar<>("Bob", 30);
        
        int vergleich = alice.vergleicheErsten(bob.getErster());
        System.out.println("Vergleich: " + vergleich); // negativ (Alice < Bob)
    }
}

4. C# Generics mit Constraints

using System;

// Generische Klasse mit Constraints
public class Repository<T> where T : class, new()
{
    private List<T> items = new List<T>();
    
    public void Add(T item)
    {
        items.Add(item);
    }
    
    public T GetById(int id)
    {
        return items.FirstOrDefault(item => GetId(item) == id);
    }
    
    public IEnumerable<T> GetAll()
    {
        return items;
    }
    
    // Methode die vom new() Constraint profitiert
    public T CreateNew()
    {
        return new T(); // Nur möglich wegen new() Constraint
    }
    
    private int GetId(T item)
    {
        // Annahme: T hat Id-Eigenschaft
        var property = typeof(T).GetProperty("Id");
        if (property != null && property.PropertyType == typeof(int))
        {
            return (int)property.GetValue(item);
        }
        return 0;
    }
}

// Entitätsklasse
public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    public Person() { }
    
    public Person(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

// Verwendung
public class RepositoryDemo
{
    public static void Main(string[] args)
    {
        var personRepo = new Repository<Person>();
        
        // Neue Person erstellen (nutzt new() Constraint)
        var person1 = personRepo.CreateNew();
        person1.Id = 1;
        person1.Name = "Alice";
        
        var person2 = new Person(2, "Bob");
        
        personRepo.Add(person1);
        personRepo.Add(person2);
        
        // Alle Personen ausgeben
        foreach (var person in personRepo.GetAll())
        {
            Console.WriteLine($"ID: {person.Id}, Name: {person.Name}");
        }
        
        // Person nach ID suchen
        var foundPerson = personRepo.GetById(1);
        Console.WriteLine($"Gefunden: {foundPerson?.Name}");
    }
}

5. C++ Templates

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

// Generische Klasse (Template)
template<typename T>
class Stack {
private:
    std::vector<T> elements;
    
public:
    void push(const T& element) {
        elements.push_back(element);
    }
    
    T pop() {
        if (elements.empty()) {
            throw std::runtime_error("Stack ist leer");
        }
        
        T element = elements.back();
        elements.pop_back();
        return element;
    }
    
    bool empty() const {
        return elements.empty();
    }
    
    size_t size() const {
        return elements.size();
    }
    
    // Template Methode innerhalb der Klasse
    void print() const {
        std::cout << "Stack [";
        for (size_t i = 0; i < elements.size(); ++i) {
            std::cout << elements[i];
            if (i < elements.size() - 1) {
                std::cout << ", ";
            }
        }
        std::cout << "]" << std::endl;
    }
};

// Template Funktion
template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// Template mit Bounded Type Parameter (Concept in C++20)
template<typename T>
requires std::is_arithmetic_v<T>
T calculateAverage(const std::vector<T>& numbers) {
    if (numbers.empty()) {
        return T{};
    }
    
    T sum = T{};
    for (const T& num : numbers) {
        sum += num;
    }
    
    return sum / static_cast<T>(numbers.size());
}

int main() {
    // Stack für verschiedene Typen
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    
    std::cout << "Int-Stack: ";
    intStack.print();
    
    Stack<std::string> stringStack;
    stringStack.push("Hallo");
    stringStack.push("Welt");
    
    std::cout << "String-Stack: ";
    stringStack.print();
    
    // Template Funktion
    std::cout << "Max(5, 10): " << max(5, 10) << std::endl;
    std::cout << "Max(3.14, 2.71): " << max(3.14, 2.71) << std::endl;
    
    // Bounded Template
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::cout << "Durchschnitt: " << calculateAverage(numbers) << std::endl;
    
    return 0;
}

PECS Regel: Producer Extends, Consumer Super

Producer (liefert Daten)

// Producer: liest aus der Liste, gibt Daten zurück
public static void processList(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num.doubleValue()); // Kann Number-Methoden aufrufen
    }
    // list.add(42); // Fehler: Kann nicht in Producer schreiben
}

Consumer (verbraucht Daten)

// Consumer: schreibt in die Liste, verbraucht Daten
public static void fillList(List<? super Integer> list) {
    list.add(1);    // Integer kann hinzugefügt werden
    list.add(2);    // Number kann hinzugefügt werden
    list.add(3);    // Object kann hinzugefügt werden
}

Type Erasure in Java

Was passiert zur Kompilierzeit?

// Source Code
public class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// Nach Type Erasure (was der JVM sieht)
public class Box {
    private Object content;
    
    public void setContent(Object content) {
        this.content = content;
    }
    
    public Object getContent() {
        return content;
    }
}

Type Casts zur Laufzeit

Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");

// Impliziter Cast bei der Rückgabe
String content = stringBox.getContent(); // Cast von Object zu String

// Type Safety zur Kompilierzeit
// stringBox.setContent(123); // Fehler zur Kompilierzeit

Vorteile und Nachteile

Vorteile von Generics

Type Safety: Kompilierzeit-Fehler statt Runtime-Fehler
Wiederverwendung: Ein Code für verschiedene Typen
Lesbarkeit: Explizite Typ-Informationen
Wartbarkeit: Weniger Code-Duplizierung
Performance: Keine Boxing/Unboxing bei Werttypen (C#)

Nachteile

Komplexität: Einarbeitung in Wildcards und Bounds
Type Erasure: Java verliert Typ-Informationen zur Laufzeit
Compilation Overhead: Längere Kompilierzeiten (C++ Templates)
Binary Compatibility: Änderungen können bestehenden Code brechen

Häufige Prüfungsfragen

Was ist Type Erasure in Java? Typ-Informationen werden zur Kompilierzeit entfernt, zur Laufzeit existieren nur Raw Types.
Erklären Sie die PECS Regel! Producer Extends (kann nur lesen), Consumer Super (kann nur schreiben).

3. **Was ist der Unterschied zwischen List<?> und List<Object>?**
   List<?> ist unbekannter Typ, List<Object> ist spezifisch für Object.

Warum braucht man Bounded Type Parameters? Um Constraints zu definieren und Methoden des Typs nutzen zu können.

Generische Klassen: Generics, Type Safety & Type Parameters

Generische Klassen: Generics, Type Safety & Type Parameters

In a Nutshell

Kompakte Fachbeschreibung

Java Generics

C# Generics

C++ Templates

Prüfungsrelevante Stichpunkte

Kernkomponenten

Praxisbeispiele

1. Einfache generische Klasse in Java

2. Generische Methoden

3. Generische Klasse mit Bounded Types

4. C# Generics mit Constraints

5. C++ Templates

PECS Regel: Producer Extends, Consumer Super

Producer (liefert Daten)

Consumer (verbraucht Daten)

Type Erasure in Java

Was passiert zur Kompilierzeit?

Type Casts zur Laufzeit

Vorteile und Nachteile

Vorteile von Generics

Nachteile

Häufige Prüfungsfragen

Wichtigste Quellen

Ähnliche Beiträge

OOP Klassenbeziehungen: Assoziation, Aggregation, Komposition & Vererbung

OOP Klassen: Statische vs Instanz-Methoden, Attribute & Beziehungen

OOP Polymorphie: Grundlagen, Dynamische Bindung & Dispatch

Generische Klassen: Generics, Type Safety & Type Parameters

IRC-Mania Die Seite rund um Sicherheit und Programmierung

In a Nutshell

Kompakte Fachbeschreibung

Java Generics

C# Generics

C++ Templates

Prüfungsrelevante Stichpunkte

Kernkomponenten

Praxisbeispiele

1. Einfache generische Klasse in Java

2. Generische Methoden

3. Generische Klasse mit Bounded Types

4. C# Generics mit Constraints

5. C++ Templates

IRC-Security.de

PECS Regel: Producer Extends, Consumer Super

Producer (liefert Daten)

Consumer (verbraucht Daten)

Type Erasure in Java

Was passiert zur Kompilierzeit?

Type Casts zur Laufzeit

Vorteile und Nachteile

Vorteile von Generics

Nachteile

Häufige Prüfungsfragen

Wichtigste Quellen

Premium VPS Hosting

Ähnliche Beiträge

OOP Klassenbeziehungen: Assoziation, Aggregation, Komposition & Vererbung

OOP Klassen: Statische vs Instanz-Methoden, Attribute & Beziehungen

OOP Polymorphie: Grundlagen, Dynamische Bindung & Dispatch