Welche Möglichkeiten bieten Generics in Java?

Generics in Java verbessern die Typsicherheit des Codes, indem sie Laufzeitfehler im Zusammenhang mit Typumwandlungen verhindern. Die wichtigsten Funktionen:

• Typüberprüfung zur Kompilierungszeit: Der Compiler überprüft die korrekte Verwendung der in Generics angegebenen Typen, was Fehler vor der Ausführung des Programms erkennt.

  // Ohne Generics - mögliche ClassCastException
  List list = new ArrayList();
  list.add("Zeichenkette");
  list.add(123); // Hinzufügen eines Integer
  String s = (String) list.get(1); // Laufzeitfehler
  
  // Mit Generics - Kompilierungsfehler
  List<String> stringList = new ArrayList<>();
  stringList.add("Zeichenkette");
  // stringList.add(123); // Kompilierungsfehler
  String str = stringList.get(0); // Sicherer Zugriff
  

• Vermeidung von Typumwandlungen (Type Casting): Generics eliminieren die Notwendigkeit expliziter Typumwandlungen beim Zugriff auf Elemente in Sammlungen oder bei parametrisierten Klassen.

  // Ohne Generics
  List list = new ArrayList();
  list.add("Hallo");
  String s = (String) list.get(0); // Explizite Typumwandlung
  
  // Mit Generics
  List<String> stringList = new ArrayList<>();
  stringList.add("Hallo");
  String str = stringList.get(0); // Keine Typumwandlung erforderlich
  

• Implementierung generischer Codes (Generische Methoden, Generische Klassen, Generische Schnittstellen): Ermöglichen die Erstellung allgemeiner Algorithmen und Datenstrukturen, die mit verschiedenen Typen arbeiten, ohne Code zu duplizieren.

  // Generische Methode zum Drucken eines Arrays
  public static <T> void printArray(T[] array) {
      for (T element : array) {
          System.out.print(element + " ");
      }
      System.out.println();
  }
  
  // Generische Klasse - Paar von Werten
  class Pair<K, V> {
      private K key;
      private V value;
  
      public Pair(K key, V value) {
          this.key = key;
          this.value = value;
      }
  
      public K getKey() { return key; }
      public V getValue() { return value; }
  }
  

• Unterstützung für Wildcards: Ermöglichen die Definition flexibler Einschränkungen für Typen in parametrisierten Typen.

  • ? (Unbegrenzte Wildcard): Beliebiger Typ.
  • ? extends T (Eingeschränkte Wildcard - Obergrenze): Der Typ muss T oder ein Subtyp davon sein.
  • ? super T (Eingeschränkte Wildcard - Untergrenze): Der Typ muss T oder ein Supertyp davon sein.

  // Methode, die eine Liste beliebigen Typs akzeptiert
  public static void processList(List<?> list) {
      // ...
  }
  
  // Methode, die eine Liste von Zahlen oder deren Subtypen akzeptiert
  public static void processNumbers(List<? extends Number> list) {
      // ...
  }
  
  // Methode, die eine Liste von Strings oder deren Supertypen akzeptiert
  public static void addStrings(List<? super String> list) {
      list.add("neuer String");
  }
  

• Verwendung im Collections Framework: Alle Hauptklassen der Sammlungen (List, Set, Map usw.) sind parametrisiert, was die Arbeit mit Sammlungen typsicher und bequem macht.

Generics sind ein Schlüsselelement moderner Java-Programmierung, das die Zuverlässigkeit und Lesbarkeit des Codes erhöht.